text
stringlengths 424
69.5k
|
|---|
### Prompt
Please formulate a Cpp solution to the following problem:
Soon there will be held the world's largest programming contest, but the testing system still has m bugs. The contest organizer, a well-known university, has no choice but to attract university students to fix all the bugs. The university has n students able to perform such work. The students realize that they are the only hope of the organizers, so they don't want to work for free: the i-th student wants to get ci 'passes' in his subjects (regardless of the volume of his work).
Bugs, like students, are not the same: every bug is characterized by complexity aj, and every student has the level of his abilities bi. Student i can fix a bug j only if the level of his abilities is not less than the complexity of the bug: bi ≥ aj, and he does it in one day. Otherwise, the bug will have to be fixed by another student. Of course, no student can work on a few bugs in one day. All bugs are not dependent on each other, so they can be corrected in any order, and different students can work simultaneously.
The university wants to fix all the bugs as quickly as possible, but giving the students the total of not more than s passes. Determine which students to use for that and come up with the schedule of work saying which student should fix which bug.
Input
The first line contains three space-separated integers: n, m and s (1 ≤ n, m ≤ 105, 0 ≤ s ≤ 109) — the number of students, the number of bugs in the system and the maximum number of passes the university is ready to give the students.
The next line contains m space-separated integers a1, a2, ..., am (1 ≤ ai ≤ 109) — the bugs' complexities.
The next line contains n space-separated integers b1, b2, ..., bn (1 ≤ bi ≤ 109) — the levels of the students' abilities.
The next line contains n space-separated integers c1, c2, ..., cn (0 ≤ ci ≤ 109) — the numbers of the passes the students want to get for their help.
Output
If the university can't correct all bugs print "NO".
Otherwise, on the first line print "YES", and on the next line print m space-separated integers: the i-th of these numbers should equal the number of the student who corrects the i-th bug in the optimal answer. The bugs should be corrected as quickly as possible (you must spend the minimum number of days), and the total given passes mustn't exceed s. If there are multiple optimal answers, you can output any of them.
Examples
Input
3 4 9
1 3 1 2
2 1 3
4 3 6
Output
YES
2 3 2 3
Input
3 4 10
2 3 1 2
2 1 3
4 3 6
Output
YES
1 3 1 3
Input
3 4 9
2 3 1 2
2 1 3
4 3 6
Output
YES
3 3 2 3
Input
3 4 5
1 3 1 2
2 1 3
5 3 6
Output
NO
Note
Consider the first sample.
The third student (with level 3) must fix the 2nd and 4th bugs (complexities 3 and 2 correspondingly) and the second student (with level 1) must fix the 1st and 3rd bugs (their complexity also equals 1). Fixing each bug takes one day for each student, so it takes 2 days to fix all bugs (the students can work in parallel).
The second student wants 3 passes for his assistance, the third student wants 6 passes. It meets the university's capabilities as it is ready to give at most 9 passes.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int n, m, s, p[N];
struct student {
int idx, level, money;
bool operator<(const student &str) const { return level > str.level; }
};
student st[N];
priority_queue<pair<int, int> > rem, have;
int ans[N];
int final[N];
int main() {
scanf("%d%d%d", &n, &m, &s);
for (int i = 0; i < m; ++i) {
scanf("%d", &p[i]);
}
for (int i = 0; i < n; ++i) {
scanf("%d", &st[i].level);
}
for (int i = 0; i < n; ++i) {
scanf("%d", &st[i].money);
st[i].idx = i + 1;
}
sort(st, st + n);
int lo = 0, hi = N;
bool there = false;
while (lo <= hi) {
int mid = (lo + hi) / 2;
int idx = 0;
long long total = 0;
while (!have.empty()) have.pop();
while (!rem.empty()) rem.pop();
for (int i = 0; i < m; ++i) rem.push(make_pair(p[i], i));
bool can = true;
while (!rem.empty()) {
int mx = rem.top().first;
while (mx <= st[idx].level) {
have.push(make_pair(-st[idx].money, st[idx].idx));
idx++;
}
if (have.empty()) {
can = false;
break;
}
int lft = mid;
total += 1LL * -have.top().first;
int res = have.top().second;
have.pop();
while (lft > 0 && !rem.empty()) {
ans[rem.top().second] = res;
rem.pop();
lft--;
}
}
if (total > s) can = false;
if (can) {
there = true;
for (int i = 0; i < m; ++i) {
final[i] = ans[i];
}
hi = mid - 1;
} else {
lo = mid + 1;
}
}
if (!there) {
puts("NO");
return 0;
}
puts("YES");
for (int i = 0; i < m; ++i) {
if (i) printf(" ");
printf("%d", final[i]);
}
puts("");
return 0;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
Nauuo is a girl who loves traveling.
One day she went to a tree, Old Driver Tree, literally, a tree with an old driver on it.
The tree is a connected graph consisting of n nodes and n-1 edges. Each node has a color, and Nauuo will visit the ODT through a simple path on the tree in the old driver's car.
Nauuo wants to visit see more different colors in her journey, but she doesn't know which simple path she will be traveling on. So, she wants to calculate the sum of the numbers of different colors on all different paths. Can you help her?
What's more, the ODT is being redecorated, so there will be m modifications, each modification will change a single node's color. Nauuo wants to know the answer after each modification too.
Note that in this problem, we consider the simple path from u to v and the simple path from v to u as two different simple paths if and only if u≠ v.
Input
The first line contains two integers n and m (2≤ n≤ 4⋅ 10^5, 1≤ m≤ 4⋅ 10^5) — the number of nodes and the number of modifications.
The second line contains n integers c_1,c_2,…,c_n (1≤ c_i≤ n), where c_i is the initial color of node i.
Each of the next n-1 lines contains two integers u and v (1≤ u,v≤ n), denoting there is an edge between u and v. It is guaranteed that the given edges form a tree.
Each of the next m lines contains two integers u and x (1≤ u,x≤ n), which means a modification that changes the color of node u into x.
Output
The output contains m+1 integers — the first integer is the answer at the beginning, the rest integers are the answers after every modification in the given order.
Examples
Input
5 3
1 2 1 2 3
1 2
1 3
3 4
3 5
3 3
4 1
4 3
Output
47
51
49
45
Input
6 1
1 1 1 1 1 1
1 2
2 3
3 4
4 5
5 6
1 2
Output
36
46
Note
Example 1
<image>
The number of colors on each simple path at the beginning:
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <class node>
struct link_cut_tree {
bool connected(node* u, node* v) { return lca(u, v) != NULL; }
int depth(node* u) {
access(u);
return get_sz(u->ch[0]);
}
node* get_root(node* u) {
access(u);
while (u->ch[0]) u = u->ch[0], u->push();
return access(u), u;
}
node* ancestor(node* u, int k) {
k = depth(u) - k;
for (;; u->push()) {
int sz = get_sz(u->ch[0]);
if (sz == k) return access(u), u;
if (sz < k)
k -= sz + 1, u = u->ch[1];
else
u = u->ch[0];
}
}
node* lca(node* u, node* v) {
if (u == v) return u;
access(u);
access(v);
if (!u->p) return NULL;
u->splay();
return u->p ?: u;
}
void link(node* u, node* v) {
make_root(v);
access(u);
set_link(v, u, 0);
v->update();
}
void cut(node* u) {
access(u);
u->ch[0]->p = NULL;
u->ch[0] = NULL;
u->update();
}
void cut(node* u, node* v) { cut(depth(u) > depth(v) ? u : v); }
void make_root(node* u) {
access(u);
u->rev ^= 1;
access(u);
}
void access(node* u) {
for (node *v = u, *pre = NULL; v; v = v->p) {
v->splay();
if (pre) v->update_vsub(pre, false);
if (v->ch[1]) v->update_vsub(v->ch[1], true);
v->ch[1] = pre;
v->update();
pre = v;
}
u->splay();
}
node* operator[](int i) { return &data[i]; }
int operator[](node* i) { return i - &data[0]; }
vector<node> data;
link_cut_tree(int n) : data(n) {}
};
template <typename pnode>
struct splay_tree {
pnode ch[2], p;
bool rev;
int sz;
splay_tree() {
ch[0] = ch[1] = p = NULL;
rev = 0;
sz = 1;
}
friend int get_sz(pnode u) { return u ? u->sz : 0; }
virtual void update() {
if (ch[0]) ch[0]->push();
if (ch[1]) ch[1]->push();
sz = 1 + get_sz(ch[0]) + get_sz(ch[1]);
}
virtual void push() {
if (rev) {
if (ch[0]) ch[0]->rev ^= 1;
if (ch[1]) ch[1]->rev ^= 1;
swap(ch[0], ch[1]);
rev = 0;
}
}
int dir() {
if (!p) return -2;
if (p->ch[0] == this) return 0;
if (p->ch[1] == this) return 1;
return -1;
}
bool is_root() { return dir() < 0; }
friend void set_link(pnode u, pnode v, int d) {
if (v) v->p = u;
if (d >= 0) u->ch[d] = v;
}
void rotate() {
int x = dir();
pnode g = p;
set_link(g->p, static_cast<pnode>(this), g->dir());
set_link(g, ch[x ^ 1], x);
set_link(static_cast<pnode>(this), g, x ^ 1);
g->update();
}
void splay() {
while (!is_root() && !p->is_root()) {
p->p->push(), p->push(), push();
dir() == p->dir() ? p->rotate() : rotate();
rotate();
}
if (!is_root()) p->push(), push(), rotate();
push(), update();
}
};
struct node : splay_tree<node*> {
using splay_tree::ch;
int rsz, vrsz;
long long chsz2, vchsz2;
node() : splay_tree() {
rsz = 1;
vrsz = chsz2 = vchsz2 = 0;
}
void update() override {
splay_tree::update();
rsz = 1 + (ch[0] ? ch[0]->rsz : 0) + (ch[1] ? ch[1]->rsz : 0) + vrsz;
chsz2 = (ch[0] ? ((long long)ch[0]->rsz * ch[0]->rsz) : 0) +
(ch[1] ? ((long long)ch[1]->rsz * ch[1]->rsz) : 0) + vchsz2;
}
void update_vsub(node* v, bool add) {
vrsz += (add ? +1 : -1) * v->rsz;
vchsz2 += (add ? +1 : -1) * (long long)v->rsz * v->rsz;
}
void push() override { splay_tree::push(); }
};
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
int n, q;
cin >> n >> q;
vector<int> col(n);
vector<vector<pair<int, int>>> e(n);
for (int i = 0, x; i < n; ++i) {
cin >> x;
--x;
e[x].push_back({0, i});
col[i] = x;
}
vector<vector<int>> adj(n + 1);
for (int i = 1, u, v; i < n; ++i) {
cin >> u >> v;
--u, --v;
adj[u].push_back(v);
adj[v].push_back(u);
}
adj[n].push_back(0);
link_cut_tree<node> lct(n + 1);
vector<int> parent(n + 1, -1);
function<void(int)> dfs = [&](int u) {
for (auto v : adj[u])
if (v != parent[u]) {
lct.link(lct[u], lct[v]);
parent[v] = u;
dfs(v);
}
};
dfs(n);
for (int i = 1, u, x; i <= q; ++i) {
cin >> u >> x;
--u, --x;
if (col[u] == x) continue;
e[col[u]].push_back({i, ~u});
e[x].push_back({i, u});
col[u] = x;
}
vector<long long> ans(q + 1);
vector<bool> nodes(n);
for (auto& c : e) {
long long last = 0, sz2 = (long long)n * n;
for (auto& i : c) {
int ru = max(i.second, ~i.second);
auto u = lct[ru], pu = lct[parent[ru]], r = lct.get_root(pu);
if (i.second < 0) {
nodes[ru] = false;
sz2 -= r->chsz2;
lct.access(u);
sz2 -= u->chsz2;
lct.link(pu, u);
lct.access(r);
sz2 += r->chsz2;
} else {
nodes[ru] = true;
sz2 -= r->chsz2;
lct.cut(u);
sz2 += u->chsz2;
lct.access(r);
sz2 += r->chsz2;
}
if (i.first > 0 || &i == &c.back() || c[&i - &c[0] + 1].first > 0) {
ans[i.first] += -last;
ans[i.first] += (last = (long long)n * n - sz2);
}
}
for (auto& i : c) {
int ru = max(i.second, ~i.second);
if (nodes[ru]) {
nodes[ru] = false;
lct.link(lct[parent[ru]], lct[ru]);
}
}
}
partial_sum(ans.begin(), ans.end(), ans.begin());
for (auto& i : ans) cout << i << "\n";
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
AtCoDeer has three cards, one red, one green and one blue.
An integer between 1 and 9 (inclusive) is written on each card: r on the red card, g on the green card and b on the blue card.
We will arrange the cards in the order red, green and blue from left to right, and read them as a three-digit integer.
Is this integer a multiple of 4?
Constraints
* 1 ≤ r, g, b ≤ 9
Input
Input is given from Standard Input in the following format:
r g b
Output
If the three-digit integer is a multiple of 4, print `YES` (case-sensitive); otherwise, print `NO`.
Examples
Input
4 3 2
Output
YES
Input
2 3 4
Output
NO
### Response
```cpp
#include<stdio.h>
int main(){
int r,g,b;
scanf("%d%d%d",&r,&g,&b);
if((r*100+g*10+b)%4==0) printf("YES");
else printf("NO");
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
In the Isle of Guernsey there are n different types of coins. For each i (1 ≤ i ≤ n), coin of type i is worth ai cents. It is possible that ai = aj for some i and j (i ≠ j).
Bessie has some set of these coins totaling t cents. She tells Jessie q pairs of integers. For each i (1 ≤ i ≤ q), the pair bi, ci tells Jessie that Bessie has a strictly greater number of coins of type bi than coins of type ci. It is known that all bi are distinct and all ci are distinct.
Help Jessie find the number of possible combinations of coins Bessie could have. Two combinations are considered different if there is some i (1 ≤ i ≤ n), such that the number of coins Bessie has of type i is different in the two combinations. Since the answer can be very large, output it modulo 1000000007 (109 + 7).
If there are no possible combinations of coins totaling t cents that satisfy Bessie's conditions, output 0.
Input
The first line contains three space-separated integers, n, q and t (1 ≤ n ≤ 300; 0 ≤ q ≤ n; 1 ≤ t ≤ 105). The second line contains n space separated integers, a1, a2, ..., an (1 ≤ ai ≤ 105). The next q lines each contain two distinct space-separated integers, bi and ci (1 ≤ bi, ci ≤ n; bi ≠ ci).
It's guaranteed that all bi are distinct and all ci are distinct.
Output
A single integer, the number of valid coin combinations that Bessie could have, modulo 1000000007 (109 + 7).
Examples
Input
4 2 17
3 1 2 5
4 2
3 4
Output
3
Input
3 2 6
3 1 1
1 2
2 3
Output
0
Input
3 2 10
1 2 3
1 2
2 1
Output
0
Note
For the first sample, the following 3 combinations give a total of 17 cents and satisfy the given conditions: {0 of type 1, 1 of type 2, 3 of type 3, 2 of type 4}, {0, 0, 6, 1}, {2, 0, 3, 1}.
No other combinations exist. Note that even though 4 occurs in both bi and ci, the problem conditions are still satisfied because all bi are distinct and all ci are distinct.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAX = 305;
const int MAX_COST = 100005;
const int MOD = 1000000007;
long long regSum[MAX], espSum[MAX];
int a[MAX], in[MAX], out[MAX], dp[2][MAX_COST][2], n;
bool mark[MAX];
vector<int> tps;
void error() {
cout << 0 << endl;
exit(0);
}
void insertPath(int v) {
if (v == -1) return;
if (mark[v] == true) error();
mark[v] = true;
tps.push_back(v);
insertPath(out[v]);
}
void sort() {
for (int j = 1; j <= n; j++)
if (in[j] == -1) insertPath(j);
if (tps.size() != n) error();
}
int main() {
int q, t;
cin >> n >> q >> t;
for (int i = 1; i <= n; i++) {
cin >> a[i];
in[i] = out[i] = -1;
}
for (int i = 0; i < q; i++) {
int b, c;
cin >> b >> c;
in[c] = b;
out[b] = c;
}
sort();
for (int i = 0; i < n; i++) {
int v = tps[i], u = in[v];
long long rs = 0, es = 0;
if (u != -1) {
rs = regSum[u];
es = espSum[u];
}
regSum[v] = rs + a[v];
espSum[v] = es + regSum[v];
}
dp[0][0][0] = 1;
for (int i = 1; i <= n; i++)
for (int j = 0; j <= t; j++)
for (int k = 0; k <= 1; k++) {
int v = tps[i - 1], u = in[v];
long long cost1, cost2;
int newK = 1;
if (k == 0) {
cost1 = j - espSum[v];
cost2 = j - (u == -1 ? 0 : espSum[u]);
} else {
cost1 = j - regSum[v];
cost2 = j;
}
if (u == -1) newK = 0;
dp[i % 2][j][k] = ((cost1 < 0 ? 0 : dp[i % 2][cost1][1]) +
(cost2 < 0 ? 0 : dp[(i - 1) % 2][cost2][newK])) %
MOD;
}
cout << dp[n % 2][t][0] << endl;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
Sometimes some words like "localization" or "internationalization" are so long that writing them many times in one text is quite tiresome.
Let's consider a word too long, if its length is strictly more than 10 characters. All too long words should be replaced with a special abbreviation.
This abbreviation is made like this: we write down the first and the last letter of a word and between them we write the number of letters between the first and the last letters. That number is in decimal system and doesn't contain any leading zeroes.
Thus, "localization" will be spelt as "l10n", and "internationalization» will be spelt as "i18n".
You are suggested to automatize the process of changing the words with abbreviations. At that all too long words should be replaced by the abbreviation and the words that are not too long should not undergo any changes.
Input
The first line contains an integer n (1 ≤ n ≤ 100). Each of the following n lines contains one word. All the words consist of lowercase Latin letters and possess the lengths of from 1 to 100 characters.
Output
Print n lines. The i-th line should contain the result of replacing of the i-th word from the input data.
Examples
Input
4
word
localization
internationalization
pneumonoultramicroscopicsilicovolcanoconiosis
Output
word
l10n
i18n
p43s
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(int argc, const char* argv[]) {
int t;
cin >> t;
while (t--) {
string word;
cin >> word;
if (word.length() > 10) {
cout << word[0] << word.length() - 2 << word[word.length() - 1] << endl;
} else {
cout << word << endl;
}
}
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
You are organizing a cycling race on the streets of the city. The city contains n junctions, some pairs of them are connected by roads; on each road you can move in any direction. No two roads connect the same pair of intersections, and no road connects the intersection with itself.
You want the race to be open to both professional athletes and beginner cyclists, and that's why you will organize the race in three nominations: easy, moderate and difficult; each participant will choose the more suitable nomination. For each nomination you must choose the route — the chain of junctions, consecutively connected by roads. Routes must meet the following conditions:
* all three routes should start at the same intersection, and finish at the same intersection (place of start and finish can't be the same);
* to avoid collisions, no two routes can have common junctions (except for the common start and finish), and can not go along the same road (irrespective of the driving direction on the road for those two routes);
* no route must pass twice through the same intersection or visit the same road twice (irrespective of the driving direction on the road for the first and second time of visit).
Preparing for the competition is about to begin, and you need to determine the routes of the race as quickly as possible. The length of the routes is not important, it is only important that all the given requirements were met.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 2·105) — the number of intersections and roads, respectively.
The following m lines contain two integers — the numbers of the intersections connected by a road (the intersections are numbered starting with 1). It is guaranteed that each pair of intersections is connected by no more than one road, and no road connects the intersection to itself.
Please note that it is not guaranteed that you can get from any junction to any other one by using the roads.
Output
If it is possible to create the routes, in the first line print "YES". In the next three lines print the descriptions of each of the three routes in the format "l p1 ... pl", where l is the number of intersections in the route, and p1, ..., pl are their numbers in the order they follow. The routes must meet all the requirements specified in the statement.
If it is impossible to make the routes in accordance with the requirements, print NO.
Examples
Input
4 4
1 2
2 3
3 4
4 1
Output
NO
Input
5 6
1 2
1 3
1 4
2 5
3 5
4 5
Output
YES
3 5 4 1
3 5 3 1
3 5 2 1
### Response
```cpp
#include <bits/stdc++.h>
const int MN = 200005;
int N, M;
std::vector<int> G[MN];
int faz[MN * 2], cnt;
std::vector<int> V[MN];
std::vector<std::pair<int, int> > E[MN];
int deg[MN];
int stk[MN], tp;
int dfn[MN], low[MN], dfc;
void Tarjan(int u) {
low[u] = dfn[u] = ++dfc;
stk[++tp] = u;
for (auto v : G[u]) {
if (!dfn[v]) {
Tarjan(v);
low[u] = std::min(low[u], low[v]);
if (low[v] == dfn[u]) {
++cnt;
for (int x = 0; x != v; --tp)
faz[x = stk[tp]] = cnt, V[cnt - N].push_back(x);
faz[cnt] = u;
V[cnt - N].push_back(u);
}
} else
low[u] = std::min(low[u], dfn[v]);
}
}
int key[MN], vis[MN];
int DFS(int u, int f) {
stk[++tp] = u;
if (f && key[u]) return 1;
if (vis[u]) return --tp, 0;
vis[u] = 1;
for (auto v : G[u])
if (v != f && DFS(v, u)) return 1;
return --tp, 0;
}
int main() {
scanf("%d%d", &N, &M), cnt = N;
for (int i = 1, x, y; i <= M; ++i)
scanf("%d%d", &x, &y), G[x].push_back(y), G[y].push_back(x);
for (int u = 1; u <= N; ++u)
if (!dfn[u]) Tarjan(u), --tp;
for (int u = 1; u <= N; ++u)
for (auto v : G[u])
if (v > u) {
int b = faz[u] == faz[v] ? faz[u] : faz[faz[u]] == v ? faz[u] : faz[v];
E[b - N].push_back({u, v});
}
for (int u = 1; u <= N; ++u) G[u].clear();
cnt -= N;
for (int i = 1; i <= cnt; ++i) {
if (V[i].size() >= E[i].size()) continue;
for (auto e : E[i]) {
int u = e.first, v = e.second;
G[u].push_back(v), G[v].push_back(u);
++deg[u], ++deg[v];
}
int p = 0;
for (auto u : V[i])
if (deg[u] >= 3) p = u;
key[p] = 1, DFS(p, 0), key[p] = 0;
static int Ans[MN];
int len = tp;
for (int j = 1; j <= tp; ++j) Ans[j] = stk[j];
for (int j = 2; j < len; ++j) key[Ans[j]] = 1;
for (auto u : V[i]) vis[u] = 0;
stk[tp = 1] = p, vis[p] = 1;
for (auto v : G[p])
if (v != Ans[2] && v != Ans[len - 1] && DFS(v, p)) break;
auto Print = [&](int *a, int x) {
int c = 1;
while (a[c] != x) ++c;
printf("%d", c);
for (int i = 1; i <= c; ++i) printf(" %d", a[i]);
putchar('\n');
};
puts("YES");
Print(stk, stk[tp]);
Print(Ans, stk[tp]);
std::reverse(Ans + 1, Ans + len + 1);
Print(Ans, stk[tp]);
return 0;
}
puts("NO");
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Consider the following arithmetic progression with n terms:
* x, x + d, x + 2d, \ldots, x + (n-1)d
What is the product of all terms in this sequence? Compute the answer modulo 1\ 000\ 003.
You are given Q queries of this form. In the i-th query, compute the answer in case x = x_i, d = d_i, n = n_i.
Constraints
* 1 \leq Q \leq 10^5
* 0 \leq x_i, d_i \leq 1\ 000\ 002
* 1 \leq n_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
Q
x_1 d_1 n_1
:
x_Q d_Q n_Q
Output
Print Q lines.
In the i-th line, print the answer for the i-th query.
Example
Input
2
7 2 4
12345 67890 2019
Output
9009
916936
### Response
```cpp
#include<stdio.h>
#include<string.h>
#include<time.h>
#include<math.h>
#include<stdlib.h>
#include<iostream>
#include<iomanip>
#include<utility>
#include<algorithm>
#include<stack>
#include<queue>
#include<map>
#include<set>
#define ll long long
#define fi first
#define sec second
#define mp make_pair
#define pb push_back
#define rep(a,b,c) for(ll a=1;a<=b;a+=c)
#define repp(a,b,c,d) for(int a=b;a<=c;a+=d)
const double PI=acos(-1);
const double EPS=1e-12;
const ll MOD=1e6+3;
const int INF=1<<30;
using namespace std;
ll fact[3000005];
void pre(){
fact[0]=1;
rep(i,3000000,1){
fact[i]=fact[i-1]*i;
fact[i]%=MOD;
}
}
ll fast(ll a,ll b){
if(b==0)return 1;
ll temp=fast(a,b/2);
temp*=temp;
temp%=MOD;
if(b%2==1)temp*=a;
return temp%MOD;
}
ll gamma(ll a){
return fact[a-1];
}
int main(){
ios::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
pre();
int in;
ll a,d,n,res;
cin>>in;
rep(i,in,1){
cin>>a>>d>>n;
res=fast(d,n);
if(d==0){
cout<<fast(a,n)<<endl;
continue;
}
if(n>=MOD){
cout<<0<<endl;
}
else{
res*=gamma((a*fast(d,MOD-2)%MOD)+n);
res%=MOD;
res*=fast(gamma((a*fast(d,MOD-2))%MOD),MOD-2);
res%=MOD;
cout<<res<<endl;
}
}
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
Misha hacked the Codeforces site. Then he decided to let all the users change their handles. A user can now change his handle any number of times. But each new handle must not be equal to any handle that is already used or that was used at some point.
Misha has a list of handle change requests. After completing the requests he wants to understand the relation between the original and the new handles of the users. Help him to do that.
Input
The first line contains integer q (1 ≤ q ≤ 1000), the number of handle change requests.
Next q lines contain the descriptions of the requests, one per line.
Each query consists of two non-empty strings old and new, separated by a space. The strings consist of lowercase and uppercase Latin letters and digits. Strings old and new are distinct. The lengths of the strings do not exceed 20.
The requests are given chronologically. In other words, by the moment of a query there is a single person with handle old, and handle new is not used and has not been used by anyone.
Output
In the first line output the integer n — the number of users that changed their handles at least once.
In the next n lines print the mapping between the old and the new handles of the users. Each of them must contain two strings, old and new, separated by a space, meaning that before the user had handle old, and after all the requests are completed, his handle is new. You may output lines in any order.
Each user who changes the handle must occur exactly once in this description.
Examples
Input
5
Misha ILoveCodeforces
Vasya Petrov
Petrov VasyaPetrov123
ILoveCodeforces MikeMirzayanov
Petya Ivanov
Output
3
Petya Ivanov
Misha MikeMirzayanov
Vasya VasyaPetrov123
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, k;
string x, y;
vector<pair<string, string> > v;
cin >> t;
while (t--) {
k = 0;
cin >> x >> y;
for (int i = 0; i < v.size(); i++) {
if (x == v[i].second) {
v[i].second = y;
k = 1;
break;
}
}
if (k == 0) {
v.push_back(make_pair(x, y));
}
}
cout << v.size() << endl;
for (int i = 0; i < v.size(); i++) {
cout << v[i].first << " " << v[i].second << endl;
}
return 0;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
One must train much to do well on wizardry contests. So, there are numerous wizardry schools and magic fees.
One of such magic schools consists of n tours. A winner of each tour gets a huge prize. The school is organised quite far away, so one will have to take all the prizes home in one go. And the bags that you've brought with you have space for no more than k huge prizes.
Besides the fact that you want to take all the prizes home, you also want to perform well. You will consider your performance good if you win at least l tours.
In fact, years of organizing contests proved to the organizers that transporting huge prizes is an issue for the participants. Alas, no one has ever invented a spell that would shrink the prizes... So, here's the solution: for some tours the winner gets a bag instead of a huge prize. Each bag is characterized by number ai — the number of huge prizes that will fit into it.
You already know the subject of all tours, so you can estimate the probability pi of winning the i-th tour. You cannot skip the tour under any circumstances.
Find the probability that you will perform well on the contest and will be able to take all won prizes home (that is, that you will be able to fit all the huge prizes that you won into the bags that you either won or brought from home).
Input
The first line contains three integers n, l, k (1 ≤ n ≤ 200, 0 ≤ l, k ≤ 200) — the number of tours, the minimum number of tours to win, and the number of prizes that you can fit in the bags brought from home, correspondingly.
The second line contains n space-separated integers, pi (0 ≤ pi ≤ 100) — the probability to win the i-th tour, in percents.
The third line contains n space-separated integers, ai (1 ≤ ai ≤ 200) — the capacity of the bag that will be awarded to you for winning the i-th tour, or else -1, if the prize for the i-th tour is a huge prize and not a bag.
Output
Print a single real number — the answer to the problem. The answer will be accepted if the absolute or relative error does not exceed 10 - 6.
Examples
Input
3 1 0
10 20 30
-1 -1 2
Output
0.300000000000
Input
1 1 1
100
123
Output
1.000000000000
Note
In the first sample we need either win no tour or win the third one. If we win nothing we wouldn't perform well. So, we must to win the third tour. Other conditions will be satisfied in this case. Probability of wining the third tour is 0.3.
In the second sample we win the only tour with probability 1.0, and go back home with bag for it.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
double dp[210][210][420];
int main() {
int n, l, k;
cin >> n >> l >> k;
int a[n];
double p[n];
for (int i = 0; i < int(n); i++) {
int x;
cin >> x;
p[i] = x / 100.0;
}
for (int i = 0; i < int(n); i++) cin >> a[i];
dp[0][0][k + 203] = 1;
for (int i = 0; i < int(n); i++) {
for (int m = 0; m < int(410 + 1); m++) {
for (int j = 0; j < int(201); j++) {
if (m + a[i] >= 0) {
dp[i + 1][j + 1][min(410, m + a[i])] += dp[i][j][m] * p[i];
}
dp[i + 1][j][m] += dp[i][j][m] * (1 - p[i]);
}
}
}
double ans = 0;
for (int m = 203; m <= 410; m++)
for (int j = l; j <= 200; j++) {
ans += dp[n][j][m];
}
printf("%.20f\n", ans);
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
Given are 1-digit positive integers a and b. Consider these two strings: the concatenation of b copies of the digit a, and the concatenation of a copies of the digit b. Which of these is lexicographically smaller?
Constraints
* 1 \leq a \leq 9
* 1 \leq b \leq 9
* a and b are integers.
Input
Input is given from Standard Input in the following format:
a b
Output
Print the lexicographically smaller of the two strings. (If the two strings are equal, print one of them.)
Examples
Input
4 3
Output
3333
Input
7 7
Output
7777777
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int a,b;
int main()
{
cin>>a>>b;
for (int i=0; i<max(a,b); i++) cout<<min(a,b);
cout<<endl;
return 0;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
There are n stone quarries in Petrograd.
Each quarry owns mi dumpers (1 ≤ i ≤ n). It is known that the first dumper of the i-th quarry has xi stones in it, the second dumper has xi + 1 stones in it, the third has xi + 2, and the mi-th dumper (the last for the i-th quarry) has xi + mi - 1 stones in it.
Two oligarchs play a well-known game Nim. Players take turns removing stones from dumpers. On each turn, a player can select any dumper and remove any non-zero amount of stones from it. The player who cannot take a stone loses.
Your task is to find out which oligarch will win, provided that both of them play optimally. The oligarchs asked you not to reveal their names. So, let's call the one who takes the first stone «tolik» and the other one «bolik».
Input
The first line of the input contains one integer number n (1 ≤ n ≤ 105) — the amount of quarries. Then there follow n lines, each of them contains two space-separated integers xi and mi (1 ≤ xi, mi ≤ 1016) — the amount of stones in the first dumper of the i-th quarry and the number of dumpers at the i-th quarry.
Output
Output «tolik» if the oligarch who takes a stone first wins, and «bolik» otherwise.
Examples
Input
2
2 1
3 2
Output
tolik
Input
4
1 1
1 1
1 1
1 1
Output
bolik
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long xs(long long to) {
to++;
long long num = 0;
for (long long i = 1; (1 > 54 ? -1 : 1) * i <= (1 > 54 ? -1 : 1) * 54;
i += (1 > 54 ? -1 : 1))
num += ((long long)1 << (i - 1)) *
((to / ((long long)1 << i) * ((long long)1 << (i - 1)) +
max((to % ((long long)1 << i)) - ((long long)1 << (i - 1)),
(long long)0)) %
(long long)2);
return num;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n, tot = 0;
cin >> n;
while (n--) {
long long x, m;
cin >> x >> m;
tot ^= (xs(x + m - 1) ^ xs(x - 1));
}
cout << (tot ? "tolik" : "bolik") << "\n";
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
There are two buttons, one of size A and one of size B.
When you press a button of size X, you get X coins and the size of that button decreases by 1.
You will press a button twice. Here, you can press the same button twice, or press both buttons once.
At most how many coins can you get?
Constraints
* All values in input are integers.
* 3 \leq A, B \leq 20
Input
Input is given from Standard Input in the following format:
A B
Output
Print the maximum number of coins you can get.
Examples
Input
5 3
Output
9
Input
3 4
Output
7
Input
6 6
Output
12
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
int a,b;
scanf("%d %d",&a,&b);
printf("%d",max(a+b,max(a,b)*2-1));
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
Iahub is very proud of his recent discovery, propagating trees. Right now, he invented a new tree, called xor-tree. After this new revolutionary discovery, he invented a game for kids which uses xor-trees.
The game is played on a tree having n nodes, numbered from 1 to n. Each node i has an initial value initi, which is either 0 or 1. The root of the tree is node 1.
One can perform several (possibly, zero) operations on the tree during the game. The only available type of operation is to pick a node x. Right after someone has picked node x, the value of node x flips, the values of sons of x remain the same, the values of sons of sons of x flips, the values of sons of sons of sons of x remain the same and so on.
The goal of the game is to get each node i to have value goali, which can also be only 0 or 1. You need to reach the goal of the game by using minimum number of operations.
Input
The first line contains an integer n (1 ≤ n ≤ 105). Each of the next n - 1 lines contains two integers ui and vi (1 ≤ ui, vi ≤ n; ui ≠ vi) meaning there is an edge between nodes ui and vi.
The next line contains n integer numbers, the i-th of them corresponds to initi (initi is either 0 or 1). The following line also contains n integer numbers, the i-th number corresponds to goali (goali is either 0 or 1).
Output
In the first line output an integer number cnt, representing the minimal number of operations you perform. Each of the next cnt lines should contain an integer xi, representing that you pick a node xi.
Examples
Input
10
2 1
3 1
4 2
5 1
6 2
7 5
8 6
9 8
10 5
1 0 1 1 0 1 0 1 0 1
1 0 1 0 0 1 1 1 0 1
Output
2
4
7
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, a, b, goal[100000], stanj[100000], bio[100000];
vector<int> g[100000], solution;
int kor;
void dfs(int x, int promp, int promn, int dub) {
int f = 0;
if (bio[x]) return;
bio[x] = 1;
if (promp % 2 == 1 && dub % 2 == 0) {
if (stanj[x] == 1) {
stanj[x] = 0;
} else {
if (stanj[x] == 0) {
stanj[x] = 1;
}
}
f = 1;
}
if (promn % 2 == 1 && dub % 2 == 1) {
if (stanj[x] == 1) {
stanj[x] = 0;
} else {
if (stanj[x] == 0) {
stanj[x] = 1;
}
}
f = 1;
}
if (stanj[x] != goal[x]) {
if (stanj[x] == 1) {
stanj[x] = 0;
} else {
if (stanj[x] == 0) {
stanj[x] = 1;
}
}
if (dub % 2 == 0) {
promp++;
} else {
promn++;
}
solution.push_back(x);
kor++;
f = 1;
}
dub++;
for (int i = 0; i < g[x].size(); i++) dfs(g[x][i], promp, promn, dub);
}
int main() {
cin >> n;
for (int i = 0; i < n - 1; i++) {
cin >> a >> b;
a--;
b--;
g[b].push_back(a);
g[a].push_back(b);
}
for (int i = 0; i < n; i++) cin >> stanj[i];
for (int i = 0; i < n; i++) cin >> goal[i];
dfs(0, 0, 0, 0);
cout << kor << endl;
for (int i = 0; i < solution.size(); i++) {
cout << solution[i] + 1 << endl;
}
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
Amr doesn't like Maths as he finds it really boring, so he usually sleeps in Maths lectures. But one day the teacher suspected that Amr is sleeping and asked him a question to make sure he wasn't.
First he gave Amr two positive integers n and k. Then he asked Amr, how many integer numbers x > 0 exist such that:
* Decimal representation of x (without leading zeroes) consists of exactly n digits;
* There exists some integer y > 0 such that:
* <image>;
* decimal representation of y is a suffix of decimal representation of x.
As the answer to this question may be pretty huge the teacher asked Amr to output only its remainder modulo a number m.
Can you help Amr escape this embarrassing situation?
Input
Input consists of three integers n, k, m (1 ≤ n ≤ 1000, 1 ≤ k ≤ 100, 1 ≤ m ≤ 109).
Output
Print the required number modulo m.
Examples
Input
1 2 1000
Output
4
Input
2 2 1000
Output
45
Input
5 3 1103
Output
590
Note
A suffix of a string S is a non-empty string that can be obtained by removing some number (possibly, zero) of first characters from S.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long n, m, k, ans;
long long dp[1100][110];
int main() {
cin >> n >> k >> m;
for (int i = 1; i < 10; i++) dp[1][i % k]++;
long long f = 1;
for (int i = 1; i < n; i++) {
f = f * 10 % k;
for (int j = 0; j < k; j++) {
int add = j == 0 ? 1 : dp[i][j];
for (int p = 1; p < 10; p++) {
dp[i + 1][(j + p * f) % k] += add;
dp[i + 1][(j + p * f) % k] %= m;
}
}
for (int j = 1; j < k; j++) {
dp[i + 1][j] += dp[i][j];
dp[i + 1][j] %= m;
}
}
ans = dp[n][0] % m;
f = 9;
for (int i = n - 1; i > 0; i--) {
ans += dp[i][0] * f % m;
ans %= m;
f = f * 10 % m;
}
cout << ans << endl;
return 0;
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
One day, at the "Russian Code Cup" event it was decided to play football as an out of competition event. All participants was divided into n teams and played several matches, two teams could not play against each other more than once.
The appointed Judge was the most experienced member — Pavel. But since he was the wisest of all, he soon got bored of the game and fell asleep. Waking up, he discovered that the tournament is over and the teams want to know the results of all the matches.
Pavel didn't want anyone to discover about him sleeping and not keeping an eye on the results, so he decided to recover the results of all games. To do this, he asked all the teams and learned that the real winner was friendship, that is, each team beat the other teams exactly k times. Help Pavel come up with chronology of the tournir that meets all the conditions, or otherwise report that there is no such table.
Input
The first line contains two integers — n and k (1 ≤ n, k ≤ 1000).
Output
In the first line print an integer m — number of the played games. The following m lines should contain the information about all the matches, one match per line. The i-th line should contain two integers ai and bi (1 ≤ ai, bi ≤ n; ai ≠ bi). The numbers ai and bi mean, that in the i-th match the team with number ai won against the team with number bi. You can assume, that the teams are numbered from 1 to n.
If a tournir that meets the conditions of the problem does not exist, then print -1.
Examples
Input
3 1
Output
3
1 2
2 3
3 1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, k, i, j, a, x;
cin >> n >> k;
x = n * (n - 1) / 2;
if (x < n * k)
cout << "-1"
<< "\n";
else {
cout << n * k << "\n";
for (int i = 1; i <= n; i++) {
a = i;
for (int j = 1; j <= k; j++) {
cout << i << " " << (a % n) + 1 << "\n";
a++;
}
}
}
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
Today Patrick waits for a visit from his friend Spongebob. To prepare for the visit, Patrick needs to buy some goodies in two stores located near his house. There is a d1 meter long road between his house and the first shop and a d2 meter long road between his house and the second shop. Also, there is a road of length d3 directly connecting these two shops to each other. Help Patrick calculate the minimum distance that he needs to walk in order to go to both shops and return to his house.
<image>
Patrick always starts at his house. He should visit both shops moving only along the three existing roads and return back to his house. He doesn't mind visiting the same shop or passing the same road multiple times. The only goal is to minimize the total distance traveled.
Input
The first line of the input contains three integers d1, d2, d3 (1 ≤ d1, d2, d3 ≤ 108) — the lengths of the paths.
* d1 is the length of the path connecting Patrick's house and the first shop;
* d2 is the length of the path connecting Patrick's house and the second shop;
* d3 is the length of the path connecting both shops.
Output
Print the minimum distance that Patrick will have to walk in order to visit both shops and return to his house.
Examples
Input
10 20 30
Output
60
Input
1 1 5
Output
4
Note
The first sample is shown on the picture in the problem statement. One of the optimal routes is: house <image> first shop <image> second shop <image> house.
In the second sample one of the optimal routes is: house <image> first shop <image> house <image> second shop <image> house.
### Response
```cpp
#include <bits/stdc++.h>
int main() {
long long int d1, d2, d3, min = 100000000000000, ans;
scanf("%lld %lld %lld", &d1, &d2, &d3);
ans = 2 * d1 + 2 * d2;
if (ans < min) min = ans;
ans = d1 + d2 + d3;
if (ans < min) min = ans;
ans = 2 * d1 + 2 * d3;
if (ans < min) min = ans;
ans = 2 * d2 + 2 * d3;
if (ans < min) min = ans;
printf("%lld\n", min);
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
Ujan needs some rest from cleaning, so he started playing with infinite sequences. He has two integers n and k. He creates an infinite sequence s by repeating the following steps.
1. Find k smallest distinct positive integers that are not in s. Let's call them u_{1}, u_{2}, …, u_{k} from the smallest to the largest.
2. Append u_{1}, u_{2}, …, u_{k} and ∑_{i=1}^{k} u_{i} to s in this order.
3. Go back to the first step.
Ujan will stop procrastinating when he writes the number n in the sequence s. Help him find the index of n in s. In other words, find the integer x such that s_{x} = n. It's possible to prove that all positive integers are included in s only once.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^{5}), the number of test cases.
Each of the following t lines contains two integers n and k (1 ≤ n ≤ 10^{18}, 2 ≤ k ≤ 10^{6}), the number to be found in the sequence s and the parameter used to create the sequence s.
Output
In each of the t lines, output the answer for the corresponding test case.
Example
Input
2
10 2
40 5
Output
11
12
Note
In the first sample, s = (1, 2, 3, 4, 5, 9, 6, 7, 13, 8, 10, 18, …). 10 is the 11-th number here, so the answer is 11.
In the second sample, s = (1, 2, 3, 4, 5, 15, 6, 7, 8, 9, 10, 40, …).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T &x) {
x = 0;
char c = getchar();
int f = 1;
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
x = x * 10 + c - '0';
c = getchar();
}
x *= f;
}
template <class T>
inline void umin(T &x, T y) {
x = x < y ? x : y;
}
template <class T>
inline void umax(T &x, T y) {
x = x > y ? x : y;
}
inline unsigned int R() {
static unsigned int seed = 416;
return seed ^= seed >> 5, seed ^= seed << 17, seed ^= seed >> 13;
}
long long n, k;
long long getblock(long long n) { return (n - 1) / (k * k + 1); }
long long getend(long long i, long long t) {
return i * (k * k + 1) + t * k + k;
}
long long getans(long long x) {
if (!x) return k * (k + 1) / 2;
long long i = x / k, t = x % k;
long long pos = getans(i);
long long off = max(min(getend(i, t) - pos + 1, k), 0LL);
return (i * k + t) * (k * k + 1) - t + k * (k + 1) / 2 + off;
}
long long getcnt(long long x) { return x + (x - 1) / k; }
int main() {
int T;
read(T);
while (T--) {
read(n);
read(k);
long long x = getblock(n);
long long pos = getans(x);
long long res;
if (pos == n)
res = (x / k * k + x % k + 1) * (k + 1);
else
res = x * k * (k + 1) + getcnt(n - x * (k * k + 1) - (pos < n));
printf("%lld\n", res);
}
return 0;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
Recently personal training sessions have finished in the Berland State University Olympiad Programmer Training Centre. By the results of these training sessions teams are composed for the oncoming team contest season. Each team consists of three people. All the students of the Centre possess numbers from 1 to 3n, and all the teams possess numbers from 1 to n. The splitting of students into teams is performed in the following manner: while there are people who are not part of a team, a person with the best total score is chosen among them (the captain of a new team), this person chooses for himself two teammates from those who is left according to his list of priorities. The list of every person's priorities is represented as a permutation from the rest of 3n - 1 students who attend the centre, besides himself.
You are given the results of personal training sessions which are a permutation of numbers from 1 to 3n, where the i-th number is the number of student who has won the i-th place. No two students share a place. You are also given the arrangement of the already formed teams in the order in which they has been created. Your task is to determine the list of priorities for the student number k. If there are several priority lists, choose the lexicographically minimal one.
Input
The first line contains an integer n (1 ≤ n ≤ 105) which is the number of resulting teams. The second line contains 3n space-separated integers from 1 to 3n which are the results of personal training sessions. It is guaranteed that every student appears in the results exactly once.
Then follow n lines each containing three integers from 1 to 3n — each line describes the members of a given team. The members of one team can be listed in any order, but the teams themselves are listed in the order in which they were created. It is guaranteed that the arrangement is correct, that is that every student is a member of exactly one team and those teams could really be created from the given results using the method described above.
The last line contains number k (1 ≤ k ≤ 3n) which is the number of a student for who the list of priorities should be found.
Output
Print 3n - 1 numbers — the lexicographically smallest list of priorities for the student number k.
The lexicographical comparison is performed by the standard < operator in modern programming languages. The list a is lexicographically less that the list b if exists such an i (1 ≤ i ≤ 3n), that ai < bi, and for any j (1 ≤ j < i) aj = bj. Note, that the list 1 9 10 is lexicographically less than the list 1 10 9. That is, the comparison of lists is different from the comparison of lines.
Examples
Input
3
5 4 1 2 6 3 7 8 9
5 6 2
9 3 4
1 7 8
4
Output
2 3 5 6 9 1 7 8
Input
3
5 4 1 2 6 3 7 8 9
5 6 2
9 3 4
1 7 8
8
Output
1 2 3 4 5 6 7 9
Input
2
4 1 3 2 5 6
4 6 5
1 2 3
4
Output
5 6 1 2 3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<int> vf, vc, vl;
unordered_map<int, int[3]> m;
priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>>
pq;
int t[300005], d[300005], win[100005];
int main() {
int n, k, a, b, c, p;
cin >> n;
for (int i = 0; i < 3 * n; i++)
cin >> t[i], d[t[i]] = -1, pq.push(make_pair(i, t[i]));
for (int i = 0; i < n; i++) {
win[i] = pq.top().second;
for (int j = 0; j < 3; j++) cin >> m[i][j], d[m[i][j]] = i;
while (!pq.empty() && d[pq.top().second] != -1) pq.pop();
}
cin >> k;
if (win[d[k]] != k) {
for (int i = 1; i <= 3 * n; i++)
if (i != k) cout << i << " ";
return 0;
}
for (int i = 0; i < d[k]; i++)
for (int j = 0; j < 3; j++) vf.push_back(m[i][j]);
for (int j = 0; j < 3; j++)
if (m[d[k]][j] != k) vc.push_back(m[d[k]][j]);
for (int i = d[k] + 1; i < n; i++)
for (int j = 0; j < 3; j++) vl.push_back(m[i][j]);
sort(vf.begin(), vf.end());
sort(vc.begin(), vc.end());
sort(vl.begin(), vl.end());
p = 0;
for (int i = 0; i < vc.size(); i++) {
while (p < vf.size() && vf[p] < vc[i]) cout << vf[p++] << " ";
cout << vc[i] << " ";
}
for (int i = 0; i < vl.size(); i++) {
while (p < vf.size() && vf[p] < vl[i]) cout << vf[p++] << " ";
cout << vl[i] << " ";
}
while (p != vf.size()) cout << vf[p++] << " ";
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
Arpa is researching the Mexican wave.
There are n spectators in the stadium, labeled from 1 to n. They start the Mexican wave at time 0.
* At time 1, the first spectator stands.
* At time 2, the second spectator stands.
* ...
* At time k, the k-th spectator stands.
* At time k + 1, the (k + 1)-th spectator stands and the first spectator sits.
* At time k + 2, the (k + 2)-th spectator stands and the second spectator sits.
* ...
* At time n, the n-th spectator stands and the (n - k)-th spectator sits.
* At time n + 1, the (n + 1 - k)-th spectator sits.
* ...
* At time n + k, the n-th spectator sits.
Arpa wants to know how many spectators are standing at time t.
Input
The first line contains three integers n, k, t (1 ≤ n ≤ 109, 1 ≤ k ≤ n, 1 ≤ t < n + k).
Output
Print single integer: how many spectators are standing at time t.
Examples
Input
10 5 3
Output
3
Input
10 5 7
Output
5
Input
10 5 12
Output
3
Note
In the following a sitting spectator is represented as -, a standing spectator is represented as ^.
* At t = 0 ---------- <image> number of standing spectators = 0.
* At t = 1 ^--------- <image> number of standing spectators = 1.
* At t = 2 ^^-------- <image> number of standing spectators = 2.
* At t = 3 ^^^------- <image> number of standing spectators = 3.
* At t = 4 ^^^^------ <image> number of standing spectators = 4.
* At t = 5 ^^^^^----- <image> number of standing spectators = 5.
* At t = 6 -^^^^^---- <image> number of standing spectators = 5.
* At t = 7 --^^^^^--- <image> number of standing spectators = 5.
* At t = 8 ---^^^^^-- <image> number of standing spectators = 5.
* At t = 9 ----^^^^^- <image> number of standing spectators = 5.
* At t = 10 -----^^^^^ <image> number of standing spectators = 5.
* At t = 11 ------^^^^ <image> number of standing spectators = 4.
* At t = 12 -------^^^ <image> number of standing spectators = 3.
* At t = 13 --------^^ <image> number of standing spectators = 2.
* At t = 14 ---------^ <image> number of standing spectators = 1.
* At t = 15 ---------- <image> number of standing spectators = 0.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
if (c <= b) {
printf("%d\n", c);
} else if (c > b && c <= a) {
printf("%d\n", b);
} else {
printf("%d\n", (b + a - c));
}
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
International Abbreviation Olympiad takes place annually starting from 1989. Each year the competition receives an abbreviation of form IAO'y, where y stands for some number of consequent last digits of the current year. Organizers always pick an abbreviation with non-empty string y that has never been used before. Among all such valid abbreviations they choose the shortest one and announce it to be the abbreviation of this year's competition.
For example, the first three Olympiads (years 1989, 1990 and 1991, respectively) received the abbreviations IAO'9, IAO'0 and IAO'1, while the competition in 2015 received an abbreviation IAO'15, as IAO'5 has been already used in 1995.
You are given a list of abbreviations. For each of them determine the year it stands for.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 1000) — the number of abbreviations to process.
Then n lines follow, each containing a single abbreviation. It's guaranteed that each abbreviation contains at most nine digits.
Output
For each abbreviation given in the input, find the year of the corresponding Olympiad.
Examples
Input
5
IAO'15
IAO'2015
IAO'1
IAO'9
IAO'0
Output
2015
12015
1991
1989
1990
Input
4
IAO'9
IAO'99
IAO'999
IAO'9999
Output
1989
1999
2999
9999
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T BigMod(T b, T p, T m) {
if (p == 0) return 1;
if (p % 2 == 0) {
T s = BigMod(b, p / 2, m);
return ((s % m) * (s % m)) % m;
}
return ((b % m) * (BigMod(b, p - 1, m) % m)) % m;
}
template <typename T>
T ModInv(T b, T m) {
return BigMod(b, m - 2, m);
}
template <typename T>
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));
}
double DEG(double x) { return (180.0 * x) / (2.0 * acos(0.0)); }
double RAD(double x) { return (x * (double)2.0 * acos(0.0)) / (180.0); }
int main() {
char s[20];
int tc, l;
long long int res, pw;
scanf("%d", &tc);
while (tc--) {
scanf("\nIAO'%s", s);
l = strlen(s);
res = 1988;
pw = 1;
for (int i = l - 1; i >= 0; i--) {
int p = atoi(s + i);
res += pw;
while (res % (pw * 10) != p) {
res += pw;
}
pw *= 10ll;
}
printf("%lld\n", res);
}
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
One day Vasya painted a Cartesian coordinate system on a piece of paper and marked some set of points (x1, y1), (x2, y2), ..., (xn, yn). Let's define neighbors for some fixed point from the given set (x, y):
* point (x', y') is (x, y)'s right neighbor, if x' > x and y' = y
* point (x', y') is (x, y)'s left neighbor, if x' < x and y' = y
* point (x', y') is (x, y)'s lower neighbor, if x' = x and y' < y
* point (x', y') is (x, y)'s upper neighbor, if x' = x and y' > y
We'll consider point (x, y) from the given set supercentral, if it has at least one upper, at least one lower, at least one left and at least one right neighbor among this set's points.
Vasya marked quite many points on the paper. Analyzing the picture manually is rather a challenge, so Vasya asked you to help him. Your task is to find the number of supercentral points in the given set.
Input
The first input line contains the only integer n (1 ≤ n ≤ 200) — the number of points in the given set. Next n lines contain the coordinates of the points written as "x y" (without the quotes) (|x|, |y| ≤ 1000), all coordinates are integers. The numbers in the line are separated by exactly one space. It is guaranteed that all points are different.
Output
Print the only number — the number of supercentral points of the given set.
Examples
Input
8
1 1
4 2
3 1
1 2
0 2
0 1
1 0
1 3
Output
2
Input
5
0 0
0 1
1 0
0 -1
-1 0
Output
1
Note
In the first sample the supercentral points are only points (1, 1) and (1, 2).
In the second sample there is one supercental point — point (0, 0).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int n;
cin >> n;
long long int a[n], b[n];
for (long long int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
}
long long int co = 0, r = 0, l = 0, u = 0, d = 0;
for (long long int i = 0; i < n; i++) {
r = 0, u = 0, l = 0, d = 0;
for (long long int j = 0; j < n; j++) {
if (a[i] == a[j] && b[i] > b[j]) {
r++;
} else if (a[i] == a[j] && b[i] < b[j]) {
l++;
}
if (a[i] > a[j] && b[i] == b[j]) {
d++;
} else if (a[i] < a[j] && b[i] == b[j]) {
u++;
}
if (l >= 1 && r >= 1 && d >= 1 && u >= 1) {
co += 1;
break;
}
}
}
cout << co << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t;
t = 1;
while (t--) {
solve();
}
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
Given are two sequences a=\\{a_0,\ldots,a_{N-1}\\} and b=\\{b_0,\ldots,b_{N-1}\\} of N non-negative integers each.
Snuke will choose an integer k such that 0 \leq k < N and an integer x not less than 0, to make a new sequence of length N, a'=\\{a_0',\ldots,a_{N-1}'\\}, as follows:
* a_i'= a_{i+k \mod N}\ XOR \ x
Find all pairs (k,x) such that a' will be equal to b.
What is \mbox{ XOR }?
The XOR of integers A and B, A \mbox{ XOR } B, is defined as follows:
* When A \mbox{ XOR } B is written in base two, the digit in the 2^k's place (k \geq 0) is 1 if either A or B, but not both, has 1 in the 2^k's place, and 0 otherwise.
For example, 3 \mbox{ XOR } 5 = 6. (In base two: 011 \mbox{ XOR } 101 = 110.)
Constraints
* 1 \leq N \leq 2 \times 10^5
* 0 \leq a_i,b_i < 2^{30}
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
a_0 a_1 ... a_{N-1}
b_0 b_1 ... b_{N-1}
Output
Print all pairs (k, x) such that a' and b will be equal, using one line for each pair, in ascending order of k (ascending order of x for pairs with the same k).
If there are no such pairs, the output should be empty.
Examples
Input
3
0 2 1
1 2 3
Output
1 3
Input
5
0 0 0 0 0
2 2 2 2 2
Output
0 2
1 2
2 2
3 2
4 2
Input
6
0 1 3 7 6 4
1 5 4 6 2 3
Output
2 2
5 5
Input
2
1 2
0 0
Output
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<int> Z_Algorithm(vector<int> &s) {
vector<int> ret(s.size());
for (int i = 1, j = 0; i < s.size(); i++) {
if (i + ret[i-j] < j + ret[j]) {
ret[i] = ret[i-j];
} else {
int k = max(0, j + ret[j] - i);
while (i+k < s.size() && s[k] == s[i+k]) k++;
ret[i] = k; j = i;
}
}
ret[0] = s.size();
return ret;
}
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n; cin >> n;
vector<int> a(n), b(n), c(3*n);
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> b[i];
for (int i = 0; i < n; i++) {
c[i] = b[i] ^ b[(i+1) % n];
c[i+n] = c[i+n*2] = a[i] ^ a[(i+1) % n];
}
auto ret = Z_Algorithm(c);
for (int k = 0; k < n; k++) {
if (ret[n+k] >= n) {
cout << k << " " << (b[0] ^ a[k]) << "\n";
}
}
return 0;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
Caracal is fighting with a monster.
The health of the monster is H.
Caracal can attack by choosing one monster. When a monster is attacked, depending on that monster's health, the following happens:
* If the monster's health is 1, it drops to 0.
* If the monster's health, X, is greater than 1, that monster disappears. Then, two new monsters appear, each with the health of \lfloor X/2 \rfloor.
(\lfloor r \rfloor denotes the greatest integer not exceeding r.)
Caracal wins when the healths of all existing monsters become 0 or below.
Find the minimum number of attacks Caracal needs to make before winning.
Constraints
* 1 \leq H \leq 10^{12}
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
H
Output
Find the minimum number of attacks Caracal needs to make before winning.
Examples
Input
2
Output
3
Input
4
Output
7
Input
1000000000000
Output
1099511627775
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main()
{
long long n;
cin>>n;
long long ans=1;
while(n!=1)
{
n/=2;
ans=ans*2+1;
}
cout<<ans;
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
At one point, there was a president who traveled around Japan to do business. One day he got a mysterious ticket. If you use the ticket, the train fare will be free regardless of the distance to the destination. However, when moving from the current station to the adjacent station is counted as one step, if the number of steps to move is not exactly equal to the number written on the ticket, an additional fee will be charged. It is forbidden to move around a section immediately, but it is permissible to go through a station or section that you have already visited multiple times. For example, you cannot move to station 1, station 2, or station 1, but there is no problem with moving to station 1, station 2, station 3, station 1, or station 2. Also, if you finally arrive at your destination, you may go through the starting point and destination as many times as you like.
The president immediately decided to use this ticket to go to his next destination. However, since the route map is complicated, the route cannot be easily determined. Your job is to write a program on behalf of the president to determine if you can reach your destination for free.
Stations are numbered from 1 to N, with the departure station being 1 and the destination station being N. The route map is given by the row of sections connecting the two stations. The section can pass in either direction. It is guaranteed that there is no section connecting the same stations and that there is at most one section connecting a pair of stations.
Input
The input consists of multiple datasets.
Each dataset is given in the following format.
N M Z
s1 d1
s2 d2
...
sM dM
N is the total number of stations, M is the total number of sections, and Z is the number of steps written on the ticket. si and di (1 ≤ i ≤ M) are integers representing station numbers, indicating that there is an interval between station si and station di, respectively.
N, M, Z are positive integers and satisfy the following conditions: 2 ≤ N ≤ 50, 1 ≤ M ≤ 50, 0 <Z <231.
After the last dataset, there is a line that says "` 0 0 0 `".
The number of datasets does not exceed 30.
Output
For each dataset, output a one-line string containing only "` yes` "if the destination can be reached with just the number of steps written on the ticket, or" `no`" if not. ..
Example
Input
2 1 1
1 2
2 1 2
1 2
3 1 2
1 2
8 8 5778
1 2
2 3
2 4
3 5
5 6
6 7
7 8
4 8
8 8 5777
1 2
2 3
2 4
3 5
5 6
6 7
7 8
4 8
0 0 0
Output
yes
no
no
yes
no
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
// typedef long long ll;
typedef int ll;
#define MAX INT_MAX
typedef vector<int> vi;
typedef vector<ll> vl;
typedef complex<double> P;
typedef pair<int,int> pii;
#define REP(i,n) for(ll i=0;i<n;++i)
#define REPR(i,n) for(ll i=1;i<n;++i)
#define FOR(i,a,b) for(ll i=a;i<b;++i)
#define DEBUG(x) cout<<#x<<": "<<x<<endl
#define DEBUG_VEC(v) cout<<#v<<":";REP(i,v.size())cout<<" "<<v[i];cout<<endl
#define ALL(a) (a).begin(),(a).end()
#define MOD (ll)(1e9+7)
#define ADD(a,b) a=((a)+(b))%MOD
#define FIX(a) ((a)%MOD+MOD)%MOD
typedef vector<ll> vec;
typedef vector<vec> mat;
#define CREATE_MATRIX(n,m) vector<vec>(n,vec(m,0ll))
mat mul(mat &a,mat &b,ll md=MAX,ll clamp=MAX){
if(a.size()==0 || b.size()==0) assert(false&&"ERROR: ????????????????????????????????????");
// a(n*l) * b(l*m)
int n = a.size();
int l = a[0].size();
int m = b[0].size();
if(b.size()!=l) assert(false&&"ERROR: ????????????????????????????????????");
mat ret = CREATE_MATRIX(n,m);
REP(i,n)REP(j,m){
REP(k,l){
ret[i][j] += a[i][k] * b[k][j] % md;
if(ret[i][j]>=clamp-1)break;
ret[i][j] %= md;
}
ret[i][j] %= clamp;
}
return ret;
}
void out_mat(mat a){
REP(i,a.size()){
REP(j,a[i].size())cout<<a[i][j]<<" ";
cout<<endl;
}
}
void out_vec(mat v){
assert(v[0].size()==1);
REP(i,v.size())cout<<v[i][0]<<" ";
cout<<endl;
}
int main(){
// verify: http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=2107
while(true){
int n,m;
ll z;
cin>>n>>m>>z;
if(!n && !m && !z)break;
vector<pii> es(m);
REP(i,m){
int x,y;
cin>>x>>y;
es[i].first = x-1;
es[i].second = y-1;
}
mat M = CREATE_MATRIX(2*m,2*m);
REP(i,m)REP(j,m){
if(i==j)continue;
if(es[i].second == es[j].first) M[j][i] = M[m+i][m+j] = 1;
if(es[i].first == es[j].second) M[i][j] = M[m+j][m+i] = 1;
if(es[i].first == es[j].first) M[j][m+i] = M[i][m+j] = 1;
if(es[i].second == es[j].second) M[m+j][i] = M[m+i][j] = 1;
}
mat X = CREATE_MATRIX(2*m,1);
REP(i,m)if(es[i].first == 0)X[i][0]=1;
REP(i,m)if(es[i].second == 0)X[m+i][0]=1;
--z;
mat ans = CREATE_MATRIX(2*m,2*m);
REP(i,2*m)ans[i][i] = 1;
while(z){
if(z&1) ans = mul(ans,M,MAX,2);
M = mul(M,M,MAX,2);
z>>=1;
}
ans = mul(ans,X,MAX,2);
bool flag = false;
REP(i,m){
if(es[i].second == n-1 && ans[i][0]>=1){
flag = true;
break;
}else if(es[i].first == n-1 && ans[i+m][0]>=1){
flag = true;
break;
}
}
if(flag)cout<<"yes"<<endl;
else cout<<"no"<<endl;
}
return 0;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
Codeforces user' handle color depends on his rating — it is red if his rating is greater or equal to 2400; it is orange if his rating is less than 2400 but greater or equal to 2200, etc. Each time participant takes part in a rated contest, his rating is changed depending on his performance.
Anton wants the color of his handle to become red. He considers his performance in the rated contest to be good if he outscored some participant, whose handle was colored red before the contest and his rating has increased after it.
Anton has written a program that analyses contest results and determines whether he performed good or not. Are you able to do the same?
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100) — the number of participants Anton has outscored in this contest .
The next n lines describe participants results: the i-th of them consists of a participant handle namei and two integers beforei and afteri ( - 4000 ≤ beforei, afteri ≤ 4000) — participant's rating before and after the contest, respectively. Each handle is a non-empty string, consisting of no more than 10 characters, which might be lowercase and uppercase English letters, digits, characters «_» and «-» characters.
It is guaranteed that all handles are distinct.
Output
Print «YES» (quotes for clarity), if Anton has performed good in the contest and «NO» (quotes for clarity) otherwise.
Examples
Input
3
Burunduk1 2526 2537
BudAlNik 2084 2214
subscriber 2833 2749
Output
YES
Input
3
Applejack 2400 2400
Fluttershy 2390 2431
Pinkie_Pie -2500 -2450
Output
NO
Note
In the first sample, Anton has outscored user with handle Burunduk1, whose handle was colored red before the contest and his rating has increased after the contest.
In the second sample, Applejack's rating has not increased after the contest, while both Fluttershy's and Pinkie_Pie's handles were not colored red before the contest.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
unsigned long long int MOD = 1000000007;
unsigned long long int B = 13331;
bool cmp(const int &a, const int &b) { return a < b; }
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int lcm(int a, int b) { return a * (b / gcd(a, b)); }
unsigned long long int int_mod(unsigned long long int a) {
return (a + MOD) % MOD;
}
unsigned long long int power_expo(unsigned long long int a,
unsigned long long int b) {
unsigned long long int t;
if (b == 0) return 1;
if (b == 1) return int_mod(a);
t = power_expo(a, b / 2);
return b % 2 == 0 ? int_mod(t * t) : int_mod(int_mod(t * t) * a);
}
int main() {
int i, j, k;
int n;
cin >> n;
string s[105];
int flag = 0;
for (i = 0; i < n; i++) {
cin >> s[i];
int a, b;
cin >> a >> b;
if (a >= 2400 && b >= 2400 && b > a) flag = 1;
}
if (flag)
cout << "YES";
else
cout << "NO";
return 0;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
You have a set of n weights. You know that their masses are a_1, a_2, ..., a_n grams, but you don't know which of them has which mass. You can't distinguish the weights.
However, your friend does know the mass of each weight. You can ask your friend to give you exactly k weights with the total mass m (both parameters k and m are chosen by you), and your friend will point to any valid subset of weights, if it is possible.
You are allowed to make this query only once. Find the maximum possible number of weights you can reveal after this query.
Input
The first line contains a single integer n (1 ≤ n ≤ 100) — the number of weights.
The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 100) — the masses of the weights.
Output
Print the maximum number of weights you can learn the masses for after making a single query.
Examples
Input
4
1 4 2 2
Output
2
Input
6
1 2 4 4 4 9
Output
2
Note
In the first example we can ask for a subset of two weights with total mass being equal to 4, and the only option is to get \{2, 2\}.
Another way to obtain the same result is to ask for a subset of two weights with the total mass of 5 and get \{1, 4\}. It is easy to see that the two remaining weights have mass of 2 grams each.
In the second example we can ask for a subset of two weights with total mass being 8, and the only answer is \{4, 4\}. We can prove it is not possible to learn masses for three weights in one query, but we won't put the proof here.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int num[110], a[110];
long long ch[12000][3];
int main() {
int n, ans = 0, i, j, k, l;
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + n + 1);
k = 0;
for (i = 1; i <= n; i++) {
if (!num[a[i]]) k++;
num[a[i]]++;
}
if (k == 2) {
printf("%d", n);
return 0;
}
ch[0][0] = 1;
for (i = 1; i <= 100; i++) {
for (j = 1; j <= num[i]; j++) {
for (k = 10000; k >= 1; k--) {
ch[k][0] = 0;
ch[k][1] = 0;
}
for (l = 1; l <= n; l++) {
for (k = 10000; k >= 0; k--) {
if (a[l] == i) continue;
if ((ch[k][0] & ((long long)1 << 50)) != 0) {
ch[k + a[l]][0] |= ((ch[k][0] - ((long long)1 << 50)) << 1);
ch[k + a[l]][1] |= ((ch[k][1] << 1) + 1);
} else {
ch[k + a[l]][0] |= (ch[k][0] << 1);
ch[k + a[l]][1] |= (ch[k][1] << 1);
}
}
}
for (l = 1; l <= j - 1; l++) {
for (k = 10000; k >= 0; k--) {
if ((ch[k][0] & ((long long)1 << 50)) != 0) {
ch[k + i][0] |= ((ch[k][0] - ((long long)1 << 50)) << 1);
ch[k + i][1] |= ((ch[k][1] << 1) + 1);
} else {
ch[k + i][0] |= (ch[k][0] << 1);
ch[k + i][1] |= (ch[k][1] << 1);
}
}
}
if (j <= 50 && (ch[i * j][0] & ((long long)1 << j)) == 0)
ans = max(ans, j);
else if (j > 50 && (ch[i * j][1] & ((long long)1 << (j - 51))) == 0)
ans = max(ans, j);
}
}
printf("%d", ans);
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
Enter a positive integer n of 4,000 or less, with a pair of integers a, b, c, d in the range 0-1000.
a + b + c + d = n
Create a program that outputs the number of combinations that satisfy the conditions.
Input
Given multiple datasets. Each dataset is given n on one row. Please process until the end of the input.
The number of datasets does not exceed 50.
Output
For each data set, output the number of combinations of a, b, c, and d on one line.
Example
Input
2
3
35
Output
10
20
8436
### Response
```cpp
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
int main() {
unordered_map<int, int> dict1;
for(int a = 0; a <= 1000; a++) {
for(int b = 0; b <= 1000; b++) {
dict1[a + b]++;
}
}
unordered_map<int, int> dict2;
for(int c = 0; c <= 1000; c++) {
for(int d = 0; d <= 1000; d++) {
dict2[c + d]++;
}
}
for(int N; cin >> N; ) {
int ans = 0;
for(auto it : dict1) {
if(dict2.count(N - it.first)) {
ans += dict1[N - it.first] * it.second;
}
}
cout << ans << endl;
}
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
This is the easy version of the problem. The difference between the versions is in the number of possible operations that can be made. You can make hacks if and only if you solved both versions of the problem.
You are given a binary table of size n × m. This table consists of symbols 0 and 1.
You can make such operation: select 3 different cells that belong to one 2 × 2 square and change the symbols in these cells (change 0 to 1 and 1 to 0).
Your task is to make all symbols in the table equal to 0. You are allowed to make at most 3nm operations. You don't need to minimize the number of operations.
It can be proved that it is always possible.
Input
The first line contains a single integer t (1 ≤ t ≤ 5000) — the number of test cases. The next lines contain descriptions of test cases.
The first line of the description of each test case contains two integers n, m (2 ≤ n, m ≤ 100).
Each of the next n lines contains a binary string of length m, describing the symbols of the next row of the table.
It is guaranteed that the sum of nm for all test cases does not exceed 20000.
Output
For each test case print the integer k (0 ≤ k ≤ 3nm) — the number of operations.
In the each of the next k lines print 6 integers x_1, y_1, x_2, y_2, x_3, y_3 (1 ≤ x_1, x_2, x_3 ≤ n, 1 ≤ y_1, y_2, y_3 ≤ m) describing the next operation. This operation will be made with three cells (x_1, y_1), (x_2, y_2), (x_3, y_3). These three cells should be different. These three cells should belong into some 2 × 2 square.
Example
Input
5
2 2
10
11
3 3
011
101
110
4 4
1111
0110
0110
1111
5 5
01011
11001
00010
11011
10000
2 3
011
101
Output
1
1 1 2 1 2 2
2
2 1 3 1 3 2
1 2 1 3 2 3
4
1 1 1 2 2 2
1 3 1 4 2 3
3 2 4 1 4 2
3 3 4 3 4 4
4
1 2 2 1 2 2
1 4 1 5 2 5
4 1 4 2 5 1
4 4 4 5 3 4
2
1 3 2 2 2 3
1 2 2 1 2 2
Note
In the first test case, it is possible to make only one operation with cells (1, 1), (2, 1), (2, 2). After that, all symbols will be equal to 0.
In the second test case:
* operation with cells (2, 1), (3, 1), (3, 2). After it the table will be:
011
001
000
* operation with cells (1, 2), (1, 3), (2, 3). After it the table will be:
000
000
000
In the fifth test case:
* operation with cells (1, 3), (2, 2), (2, 3). After it the table will be:
010
110
* operation with cells (1, 2), (2, 1), (2, 2). After it the table will be:
000
000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 100 + 10;
string s[N];
int n, m;
int a[N][N];
struct node {
int a, b, c, d, e, f;
};
vector<node> v;
void work() {
cin >> n >> m;
for (int i = 0; i <= n - 1; i++) cin >> s[i];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) a[i][j] = s[i - 1][j - 1] - '0';
v.clear();
if (n & 1) {
for (int i = 1; i <= m; i++)
if (a[n][i]) {
if (i == 1) {
a[n - 1][i] ^= 1;
a[n - 1][i + 1] ^= 1;
v.push_back({n, i, n - 1, i, n - 1, i + 1});
} else {
a[n - 1][i] ^= 1;
a[n - 1][i - 1] ^= 1;
v.push_back({n, i, n - 1, i, n - 1, i - 1});
}
}
--n;
}
if (m & 1) {
for (int i = 1; i <= n; i++)
if (a[i][m]) {
if (i == 1) {
a[i][m - 1] ^= 1;
a[i + 1][m - 1] ^= 1;
v.push_back({i, m, i, m - 1, i + 1, m - 1});
} else {
a[i][m - 1] ^= 1;
a[i - 1][m - 1] ^= 1;
v.push_back({i, m, i, m - 1, i - 1, m - 1});
}
}
--m;
}
for (int i = 1; i <= n; i += 2)
for (int j = 1; j <= m; j += 2) {
int A = 0, b = 0, c = 0, d = 0;
if (a[i][j]) b ^= 1, c ^= 1, d ^= 1;
if (a[i][j + 1]) A ^= 1, c ^= 1, d ^= 1;
if (a[i + 1][j]) A ^= 1, b ^= 1, d ^= 1;
if (a[i + 1][j + 1]) A ^= 1, b ^= 1, c ^= 1;
if (A) v.push_back({i, j + 1, i + 1, j, i + 1, j + 1});
if (b) v.push_back({i, j, i + 1, j, i + 1, j + 1});
if (c) v.push_back({i, j, i, j + 1, i + 1, j + 1});
if (d) v.push_back({i, j, i, j + 1, i + 1, j});
}
cout << v.size() << endl;
for (auto v1 : v) {
cout << v1.a << " " << v1.b << " ";
cout << v1.c << " " << v1.d << " ";
cout << v1.e << " " << v1.f << '\n';
}
}
int main() {
int t;
cin >> t;
while (t--) work();
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
Two famous competing companies ChemForces and TopChemist decided to show their sets of recently discovered chemical elements on an exhibition. However they know that no element should be present in the sets of both companies.
In order to avoid this representatives of both companies decided to make an agreement on the sets the companies should present. The sets should be chosen in the way that maximizes the total income of the companies.
All elements are enumerated with integers. The ChemForces company has discovered n distinct chemical elements with indices a_1, a_2, …, a_n, and will get an income of x_i Berland rubles if the i-th element from this list is in the set of this company.
The TopChemist company discovered m distinct chemical elements with indices b_1, b_2, …, b_m, and it will get an income of y_j Berland rubles for including the j-th element from this list to its set.
In other words, the first company can present any subset of elements from \\{a_1, a_2, …, a_n\} (possibly empty subset), the second company can present any subset of elements from \\{b_1, b_2, …, b_m\} (possibly empty subset). There shouldn't be equal elements in the subsets.
Help the representatives select the sets in such a way that no element is presented in both sets and the total income is the maximum possible.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^5) — the number of elements discovered by ChemForces.
The i-th of the next n lines contains two integers a_i and x_i (1 ≤ a_i ≤ 10^9, 1 ≤ x_i ≤ 10^9) — the index of the i-th element and the income of its usage on the exhibition. It is guaranteed that all a_i are distinct.
The next line contains a single integer m (1 ≤ m ≤ 10^5) — the number of chemicals invented by TopChemist.
The j-th of the next m lines contains two integers b_j and y_j, (1 ≤ b_j ≤ 10^9, 1 ≤ y_j ≤ 10^9) — the index of the j-th element and the income of its usage on the exhibition. It is guaranteed that all b_j are distinct.
Output
Print the maximum total income you can obtain by choosing the sets for both companies in such a way that no element is presented in both sets.
Examples
Input
3
1 2
7 2
3 10
4
1 4
2 4
3 4
4 4
Output
24
Input
1
1000000000 239
3
14 15
92 65
35 89
Output
408
Note
In the first example ChemForces can choose the set (3, 7), while TopChemist can choose (1, 2, 4). This way the total income is (10 + 2) + (4 + 4 + 4) = 24.
In the second example ChemForces can choose the only element 10^9, while TopChemist can choose (14, 92, 35). This way the total income is (239) + (15 + 65 + 89) = 408.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct node {
long long pos, x;
} p[222222];
bool cmp(node a, node b) {
if (a.pos != b.pos) {
return a.pos < b.pos;
}
return a.x > b.x;
}
int main() {
int n, m;
int num = 0;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%lld %lld", &p[num].pos, &p[num].x);
num++;
}
scanf("%d", &m);
for (int i = 0; i < m; i++) {
scanf("%lld %lld", &p[num].pos, &p[num].x);
num++;
}
sort(p, p + num, cmp);
long long sum = 0;
int i = 0;
while (i < num) {
long long now = p[i].pos;
sum += p[i].x;
while (p[i].pos == now && i < num) {
i++;
}
if (i >= num) {
break;
}
}
printf("%lld\n", sum);
return 0;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
Mr. Infinity has a string S consisting of digits from `1` to `9`. Each time the date changes, this string changes as follows:
* Each occurrence of `2` in S is replaced with `22`. Similarly, each `3` becomes `333`, `4` becomes `4444`, `5` becomes `55555`, `6` becomes `666666`, `7` becomes `7777777`, `8` becomes `88888888` and `9` becomes `999999999`. `1` remains as `1`.
For example, if S is `1324`, it becomes `1333224444` the next day, and it becomes `133333333322224444444444444444` the day after next. You are interested in what the string looks like after 5 \times 10^{15} days. What is the K-th character from the left in the string after 5 \times 10^{15} days?
Constraints
* S is a string of length between 1 and 100 (inclusive).
* K is an integer between 1 and 10^{18} (inclusive).
* The length of the string after 5 \times 10^{15} days is at least K.
Input
Input is given from Standard Input in the following format:
S
K
Output
Print the K-th character from the left in Mr. Infinity's string after 5 \times 10^{15} days.
Examples
Input
1214
4
Output
2
Input
3
157
Output
3
Input
299792458
9460730472580800
Output
2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string S;
long N,a=0;
cin>>S>>N;
for(long long i=0;i<N;i++){
if(S.at(i)!='1'){
cout<<S.at(i);
a=1;
break;
}
}
if(a==0){
cout<<'1';
}
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
Piegirl has found a monster and a book about monsters and pies. When she is reading the book, she found out that there are n types of monsters, each with an ID between 1 and n. If you feed a pie to a monster, the monster will split into some number of monsters (possibly zero), and at least one colorful diamond. Monsters may be able to split in multiple ways.
At the begining Piegirl has exactly one monster. She begins by feeding the monster a pie. She continues feeding pies to monsters until no more monsters are left. Then she collects all the diamonds that were created.
You will be given a list of split rules describing the way in which the various monsters can split. Every monster can split in at least one way, and if a monster can split in multiple ways then each time when it splits Piegirl can choose the way it splits.
For each monster, determine the smallest and the largest number of diamonds Piegirl can possibly collect, if initially she has a single instance of that monster. Piegirl has an unlimited supply of pies.
Input
The first line contains two integers: m and n (1 ≤ m, n ≤ 105), the number of possible splits and the number of different monster types. Each of the following m lines contains a split rule. Each split rule starts with an integer (a monster ID) mi (1 ≤ mi ≤ n), and a positive integer li indicating the number of monsters and diamonds the current monster can split into. This is followed by li integers, with positive integers representing a monster ID and -1 representing a diamond.
Each monster will have at least one split rule. Each split rule will have at least one diamond. The sum of li across all split rules will be at most 105.
Output
For each monster, in order of their IDs, print a line with two integers: the smallest and the largest number of diamonds that can possibly be collected by starting with that monster. If Piegirl cannot possibly end up in a state without monsters, print -1 for both smallest and the largest value. If she can collect an arbitrarily large number of diamonds, print -2 as the largest number of diamonds.
If any number in output exceeds 314000000 (but is finite), print 314000000 instead of that number.
Examples
Input
6 4
1 3 -1 1 -1
1 2 -1 -1
2 3 -1 3 -1
2 3 -1 -1 -1
3 2 -1 -1
4 2 4 -1
Output
2 -2
3 4
2 2
-1 -1
Input
3 2
1 2 1 -1
2 2 -1 -1
2 3 2 1 -1
Output
-1 -1
2 2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <typename T0, typename T1>
bool chkmin(T0 &a, const T1 &b) {
return a > b ? a = b, 1 : 0;
}
template <typename T0, typename T1>
bool chkmax(T0 &a, const T1 &b) {
return a < b ? a = b, 1 : 0;
}
const int oo = 0x3f3f3f3f, Max_val = 314000000;
const int maxn = 100000, maxm = 100000;
int deg[maxn + 5];
pair<pair<int, int>, int> all[maxm + 5];
int tmp[maxm + 5] = {0};
vector<int> yyt[maxn + 5];
bool vis[maxn + 5] = {0};
int Min[maxn + 5];
int Max[maxn + 5];
vector<int> zzj[maxm + 5];
vector<int> owaski[maxn + 5];
int find(const int &first) {
if (vis[first]) return -2;
if (Max[first]) return Max[first];
vis[first] = 1;
Max[first] = -2;
for (int i = (0), _end_ = ((int((owaski[first]).size()))); i != _end_; ++i) {
const int &second = owaski[first][i];
int tmp = ::tmp[second];
for (int j = (0), _end_ = ((int((zzj[second]).size()))); j != _end_; ++j) {
const int &k = zzj[second][j];
int tmp0 = find(k);
if (tmp0 == -1)
goto yyt;
else if (tmp0 == -2)
tmp = -2;
else if (tmp != -2)
chkmin(tmp += tmp0, Max_val);
}
if (tmp == -2) {
Max[first] = -2;
vis[first] = 0;
return Max[first];
}
Max[first] = max(Max[first], tmp);
yyt:;
}
vis[first] = 0;
return Max[first];
}
int m, n;
int main() {
memset(Min, oo, sizeof Min);
scanf("%d%d", &m, &n);
for (int i = (0), _end_ = (m); i != _end_; ++i) {
scanf("%d", &all[i].first.first), --all[i].first.first;
static int nn;
scanf("%d", &nn);
all[i].first.second = tmp[i] = 0;
owaski[all[i].first.first].push_back(i);
for (int j = (0), _end_ = (nn); j != _end_; ++j) {
static int first;
scanf("%d", &first);
if (first == -1)
++all[i].first.second, ++tmp[i];
else
--first, ++all[i].second, yyt[first].push_back(i),
zzj[i].push_back(first);
}
}
for (int i = (0), _end_ = (m); i != _end_; ++i)
if (!all[i].second) chkmin(Min[all[i].first.first], all[i].first.second);
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
q;
for (int i = (0), _end_ = (n); i != _end_; ++i)
if (Min[i] < oo) q.push(make_pair(Min[i], i));
while (!q.empty()) {
int first = q.top().second;
q.pop();
if (vis[first]) continue;
vis[first] = 1;
for (int i = (0), _end_ = ((int((yyt[first]).size()))); i != _end_; ++i) {
const int &second = yyt[first][i];
all[second].first.second =
min(all[second].first.second + Min[first], Max_val);
if (!--all[second].second &&
chkmin(Min[all[second].first.first], all[second].first.second))
q.push(
make_pair(Min[all[second].first.first], all[second].first.first));
}
}
memset(vis, 0, sizeof vis);
memset(Max, 0, sizeof Max);
for (int i = (0), _end_ = (n); i != _end_; ++i)
if (Min[i] == oo) Min[i] = Max[i] = -1;
for (int i = (0), _end_ = (n); i != _end_; ++i) {
find(i);
printf("%d %d\n", Min[i], Max[i]);
}
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
When Valera was playing football on a stadium, it suddenly began to rain. Valera hid in the corridor under the grandstand not to get wet. However, the desire to play was so great that he decided to train his hitting the ball right in this corridor. Valera went back far enough, put the ball and hit it. The ball bounced off the walls, the ceiling and the floor corridor and finally hit the exit door. As the ball was wet, it left a spot on the door. Now Valera wants to know the coordinates for this spot.
Let's describe the event more formally. The ball will be considered a point in space. The door of the corridor will be considered a rectangle located on plane xOz, such that the lower left corner of the door is located at point (0, 0, 0), and the upper right corner is located at point (a, 0, b) . The corridor will be considered as a rectangular parallelepiped, infinite in the direction of increasing coordinates of y. In this corridor the floor will be considered as plane xOy, and the ceiling as plane, parallel to xOy and passing through point (a, 0, b). We will also assume that one of the walls is plane yOz, and the other wall is plane, parallel to yOz and passing through point (a, 0, b).
We'll say that the ball hit the door when its coordinate y was equal to 0. Thus the coordinates of the spot are point (x0, 0, z0), where 0 ≤ x0 ≤ a, 0 ≤ z0 ≤ b. To hit the ball, Valera steps away from the door at distance m and puts the ball in the center of the corridor at point <image>. After the hit the ball flies at speed (vx, vy, vz). This means that if the ball has coordinates (x, y, z), then after one second it will have coordinates (x + vx, y + vy, z + vz).
See image in notes for clarification.
When the ball collides with the ceiling, the floor or a wall of the corridor, it bounces off in accordance with the laws of reflection (the angle of incidence equals the angle of reflection). In the problem we consider the ideal physical model, so we can assume that there is no air resistance, friction force, or any loss of energy.
Input
The first line contains three space-separated integers a, b, m (1 ≤ a, b, m ≤ 100). The first two integers specify point (a, 0, b), through which the ceiling and one of the corridor walls pass. The third integer is the distance at which Valera went away from the door.
The second line has three space-separated integers vx, vy, vz (|vx|, |vy|, |vz| ≤ 100, vy < 0, vz ≥ 0) — the speed of the ball after the hit.
It is guaranteed that the ball hits the door.
Output
Print two real numbers x0, z0 — the x and z coordinates of point (x0, 0, z0), at which the ball hits the exit door. The answer will be considered correct, if its absolute or relative error does not exceed 10 - 6.
Examples
Input
7 2 11
3 -11 2
Output
6.5000000000 2.0000000000
Input
7 2 11
4 -3 3
Output
4.1666666667 1.0000000000
Note
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(void) {
long double a, b, m;
cin >> a >> b >> m;
long double vx, vy, vz;
cin >> vx >> vy >> vz;
long double x = a / 2;
long double z = 0;
long double t = -m / vy;
if (vx > 0) {
x = x + (t * vx);
while (x > 2 * a) x -= 2 * a;
} else {
long double temp = t * vx;
temp = abs(temp);
x = abs(temp - x);
while (x > 2 * a) x -= 2 * a;
}
z = abs(t * vz);
while (z > 2 * b) z -= 2 * b;
if (x > a) x = abs(2 * a - x);
if (z > b) z = abs(2 * b - z);
cout << fixed << setprecision(12) << endl;
cout << x << " " << z << endl;
return 0;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
As behooves any intelligent schoolboy, Kevin Sun is studying psycowlogy, cowculus, and cryptcowgraphy at the Bovinia State University (BGU) under Farmer Ivan. During his Mathematics of Olympiads (MoO) class, Kevin was confronted with a weird functional equation and needs your help. For two fixed integers k and p, where p is an odd prime number, the functional equation states that
<image>
for some function <image>. (This equation should hold for any integer x in the range 0 to p - 1, inclusive.)
It turns out that f can actually be many different functions. Instead of finding a solution, Kevin wants you to count the number of distinct functions f that satisfy this equation. Since the answer may be very large, you should print your result modulo 109 + 7.
Input
The input consists of two space-separated integers p and k (3 ≤ p ≤ 1 000 000, 0 ≤ k ≤ p - 1) on a single line. It is guaranteed that p is an odd prime number.
Output
Print a single integer, the number of distinct functions f modulo 109 + 7.
Examples
Input
3 2
Output
3
Input
5 4
Output
25
Note
In the first sample, p = 3 and k = 2. The following functions work:
1. f(0) = 0, f(1) = 1, f(2) = 2.
2. f(0) = 0, f(1) = 2, f(2) = 1.
3. f(0) = f(1) = f(2) = 0.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18 + 1;
inline long long input(void) {
char t;
long long x = 0;
int neg = 0;
t = getchar();
while ((t < 48 || t > 57) && t != '-') t = getchar();
if (t == '-') {
neg = 1;
t = getchar();
}
while (t >= 48 && t <= 57) {
x = (x << 3) + (x << 1) + t - 48;
t = getchar();
}
if (neg) x = -x;
return x;
}
inline void output(long long x) {
char a[20];
int i = 0, j;
a[0] = '0';
if (x < 0) {
putchar('-');
x = -x;
}
if (x == 0) putchar('0');
while (x) {
a[i++] = x % 10 + 48;
x /= 10;
}
for (j = i - 1; j >= 0; j--) {
putchar(a[j]);
}
putchar('\n');
}
long long vis[1000010];
int main() {
long long n, p, cycles = 0, ans = 1;
n = input();
p = input();
if (p == 0)
cycles = n - 1;
else if (p == 1)
cycles = n;
else {
for (int i = 1; i < n; ++i) {
if (!vis[i]) {
while (!vis[i]) {
vis[i] = 1;
i = (p * i) % n;
}
cycles++;
}
}
}
for (int i = 0; i < cycles; ++i) ans = (n * ans) % 1000000007;
output(ans);
return 0;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
You invited n guests to dinner! You plan to arrange one or more circles of chairs. Each chair is going to be either occupied by one guest, or be empty. You can make any number of circles.
Your guests happen to be a little bit shy, so the i-th guest wants to have a least l_i free chairs to the left of his chair, and at least r_i free chairs to the right. The "left" and "right" directions are chosen assuming all guests are going to be seated towards the center of the circle. Note that when a guest is the only one in his circle, the l_i chairs to his left and r_i chairs to his right may overlap.
What is smallest total number of chairs you have to use?
Input
First line contains one integer n — number of guests, (1 ⩽ n ⩽ 10^5).
Next n lines contain n pairs of space-separated integers l_i and r_i (0 ⩽ l_i, r_i ⩽ 10^9).
Output
Output a single integer — the smallest number of chairs you have to use.
Examples
Input
3
1 1
1 1
1 1
Output
6
Input
4
1 2
2 1
3 5
5 3
Output
15
Input
1
5 6
Output
7
Note
In the second sample the only optimal answer is to use two circles: a circle with 5 chairs accomodating guests 1 and 2, and another one with 10 chairs accomodationg guests 3 and 4.
In the third sample, you have only one circle with one person. The guest should have at least five free chairs to his left, and at least six free chairs to his right to the next person, which is in this case the guest herself. So, overall number of chairs should be at least 6+1=7.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long ct = n;
long long l[n], r[n];
for (int i = 0; i < n; i++) cin >> l[i] >> r[i];
sort(l, l + n);
sort(r, r + n);
for (int i = 0; i < n; i++) ct += max(l[i], r[i]);
cout << ct;
return 0;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
Vasya plays a computer game with ninjas. At this stage Vasya's ninja should get out of a deep canyon.
The canyon consists of two vertical parallel walls, their height is n meters. Let's imagine that we split these walls into 1 meter-long areas and number them with positive integers from 1 to n from bottom to top. Some areas are safe and the ninja can climb them. Others are spiky and ninja can't be there. Let's call such areas dangerous.
Initially the ninja is on the lower area of the left wall. He can use each second to perform one of the following actions:
* climb one area up;
* climb one area down;
* jump to the opposite wall. That gets the ninja to the area that is exactly k meters higher than the area he jumped from. More formally, if before the jump the ninja is located at area x of one wall, then after the jump he is located at area x + k of the other wall.
If at some point of time the ninja tries to get to an area with a number larger than n, then we can assume that the ninja got out of the canyon.
The canyon gets flooded and each second the water level raises one meter. Initially the water level is at the lower border of the first area. Ninja cannot be on the area covered by water. We can assume that the ninja and the water "move in turns" — first the ninja performs some action, then the water raises for one meter, then the ninja performs one more action and so on.
The level is considered completed if the ninja manages to get out of the canyon.
After several failed attempts Vasya started to doubt whether it is possible to complete the level at all. Help him answer the question.
Input
The first line contains two integers n and k (1 ≤ n, k ≤ 105) — the height of the canyon and the height of ninja's jump, correspondingly.
The second line contains the description of the left wall — a string with the length of n characters. The i-th character represents the state of the i-th wall area: character "X" represents a dangerous area and character "-" represents a safe area.
The third line describes the right wall in the same format.
It is guaranteed that the first area of the left wall is not dangerous.
Output
Print "YES" (without the quotes) if the ninja can get out from the canyon, otherwise, print "NO" (without the quotes).
Examples
Input
7 3
---X--X
-X--XX-
Output
YES
Input
6 2
--X-X-
X--XX-
Output
NO
Note
In the first sample the ninja should first jump to the right wall, then go one meter down along the right wall, then jump to the left wall. The next jump can get the ninja from the canyon.
In the second sample there's no way the ninja can get out of the canyon.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int nmax = 200009;
priority_queue<pair<int, int> > Q;
char s[2][nmax];
int F[2][nmax];
void go(int v, int w, int t) {
if (v > 0 && (F[w][v] == -1 || t < F[w][v]) && s[w][v] != 'X') {
if (t < v) {
F[w][v] = t;
Q.push(make_pair(-t, (v << 1) + w));
}
}
}
int n, k;
int main() {
scanf("%d %d", &n, &k);
scanf("%s", &s[0][1]);
scanf("%s", &s[1][1]);
memset(F, -1, sizeof(F));
F[0][1] = 0;
Q.push(make_pair(0, 1 << 1));
bool ok = false;
while (!Q.empty()) {
int v = Q.top().second;
int w = v & 1;
v >>= 1;
int d = -Q.top().first;
Q.pop();
if (v > n) {
ok = true;
break;
}
if (d == F[w][v]) {
go(v + 1, w, d + 1);
go(v - 1, w, d + 1);
go(v + k, 1 - w, d + 1);
}
}
if (ok)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
Sereja is interested in intervals of numbers, so he has prepared a problem about intervals for you. An interval of numbers is a pair of integers [l, r] (1 ≤ l ≤ r ≤ m). Interval [l1, r1] belongs to interval [l2, r2] if the following condition is met: l2 ≤ l1 ≤ r1 ≤ r2.
Sereja wants to write out a sequence of n intervals [l1, r1], [l2, r2], ..., [ln, rn] on a piece of paper. At that, no interval in the sequence can belong to some other interval of the sequence. Also, Sereja loves number x very much and he wants some (at least one) interval in the sequence to have li = x. Sereja wonders, how many distinct ways to write such intervals are there?
Help Sereja and find the required number of ways modulo 1000000007 (109 + 7).
Two ways are considered distinct if there is such j (1 ≤ j ≤ n), that the j-th intervals in two corresponding sequences are not equal.
Input
The first line contains integers n, m, x (1 ≤ n·m ≤ 100000, 1 ≤ x ≤ m) — the number of segments in the sequence, the constraints on the numbers in segments and Sereja's favourite number.
Output
In a single line print the answer modulo 1000000007 (109 + 7).
Examples
Input
1 1 1
Output
1
Input
3 5 1
Output
240
Input
2 3 3
Output
6
Note
In third example next sequences will be correct: {[1, 1], [3, 3]}, {[1, 2], [3, 3]}, {[2, 2], [3, 3]}, {[3, 3], [1, 1]}, {[3, 3], [2, 2]}, {[3, 3], [1, 2]}.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
vector<vector<vector<long long>>> dp;
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n, m, x;
cin >> n >> m >> x;
if (n > m) {
cout << 0;
return 0;
}
dp.resize(m + 1);
for (long long i = 0; i <= m; i++) {
dp[i].resize(n + 2);
for (long long j = 0; j <= n + 1; j++) dp[i][j].resize(n + 2);
}
dp[0][0][0] = 1;
for (long long i = 1; i <= m; i++) {
if (i < x) dp[i][0][0] = 1;
for (long long j = 1; j <= n; j++) {
for (long long k = 0; k <= n; k++) {
dp[i][j][k] = dp[i - 1][j - 1][k];
if (k) dp[i][j][k] += dp[i - 1][j - 1][k - 1];
dp[i][j][k] %= mod;
if (i != x) {
dp[i][j][k] += dp[i - 1][j][k];
dp[i][j][k] += dp[i - 1][j][k + 1];
dp[i][j][k] %= mod;
}
}
}
}
long long ans = dp[m][n][0];
for (long long i = 1; i <= n; i++) ans = ans * i % mod;
cout << ans;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
You are given n points on a plane. All points are different.
Find the number of different groups of three points (A, B, C) such that point B is the middle of segment AC.
The groups of three points are considered unordered, that is, if point B is the middle of segment AC, then groups (A, B, C) and (C, B, A) are considered the same.
Input
The first line contains a single integer n (3 ≤ n ≤ 3000) — the number of points.
Next n lines contain the points. The i-th line contains coordinates of the i-th point: two space-separated integers xi, yi ( - 1000 ≤ xi, yi ≤ 1000).
It is guaranteed that all given points are different.
Output
Print the single number — the answer to the problem.
Examples
Input
3
1 1
2 2
3 3
Output
1
Input
3
0 0
-1 0
0 1
Output
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<pair<int, int> > a(n, make_pair(1000, 1000));
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
a[i].first += x;
a[i].second += y;
}
vector<vector<bool> > vis(2001, vector<bool>(2001));
for (int i = 0; i < 2001; i++)
for (int j = 0; j < 2001; j++) vis[i][j] = false;
for (int i = 0; i < n; i++) {
vis[a[i].first][a[i].second] = true;
}
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = n - 1; j > i; j--) {
float x = (a[i].first + a[j].first) / (float)2;
float y = (a[i].second + a[j].second) / (float)2;
if ((x == (int)x) && (y == (int)y) && vis[x][y]) ans++;
}
}
cout << ans << endl;
return 0;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
Japan achieved the second straight victory in the national baseball competition WBC !! A baseball tournament was held at Aizu Gakuen High School as baseball became more popular. In this tournament, a round-robin league match will be held and the ranking will be decided in the following ways.
1. The team with the most wins is ranked high
2. If the number of wins is the same, the team with the fewest losses will be ranked higher.
Create a program that inputs the results of each team and outputs the team names in order from the top team. If there are teams with the same rank, output them in the order of input. However, the number of teams n is an integer from 2 to 10 and the team name t is a single-byte alphabetic character. , 2 for a draw. Also, the team name shall be unique.
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
score1
score2
::
scoren
The number of teams n (2 ≤ n ≤ 10) is given on the first line, and the scorei of the i-th team is given on the following n lines. Each grade is given in the following format.
t r1 r2 ... rn−1
The team name t (one-character half-width alphabetic character) and the result ri (0, 1, or 2) for each match of t are given separated by blanks.
The number of datasets does not exceed 50.
Output
For each dataset, the team name is output in order from the top team.
Example
Input
6
A 1 0 0 2 0
B 0 0 1 1 0
C 1 1 1 1 1
D 1 0 0 1 2
E 2 0 0 0 0
F 1 1 0 2 1
4
g 1 1 1
h 0 1 2
w 0 0 0
b 0 2 1
0
Output
E
A
B
D
F
C
w
h
b
g
### Response
```cpp
#include<iostream>
#include<cmath>
using namespace std;
struct record
{
char t;
int w, l;
};
void sort( record* a, int n )
{
for( int i = 0; i < n; i++ )
for( int j = n - 1; j >= i + 1; j-- )
if( a[j].w > a[j-1].w )
{
record temp = a[j];
a[j] = a[j-1];
a[j-1] = temp;
}
for( int i = 0; i < n; i++ )
for( int j = n - 1; j >= i + 1; j-- )
if( a[j].w == a[j-1].w && a[j].l < a[j-1].l )
{
record temp = a[j];
a[j] = a[j-1];
a[j-1] = temp;
}
}
int main()
{
int n;
char d;
record team[10];
while( cin >> n )
{
if( n == 0 )
break;
for( int i = 0; i < n; i++ )
{
cin >> d;
team[i].t = d;
int a = 0, b = 0;
for( int j = 0; j < n - 1; j++ )
{
cin >> d;
if( d == '0' )
a++;
else if( d == '1' )
b++;
else if( d == '2' );
else;
}
team[i].w = a;
team[i].l = b;
}
sort( team, n );
for( int i = 0; i < n; i++ )
cout << team[i].t << endl;
}
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
You are given an integer n and an integer k.
In one step you can do one of the following moves:
* decrease n by 1;
* divide n by k if n is divisible by k.
For example, if n = 27 and k = 3 you can do the following steps: 27 → 26 → 25 → 24 → 8 → 7 → 6 → 2 → 1 → 0.
You are asked to calculate the minimum number of steps to reach 0 from n.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of queries.
The only line of each query contains two integers n and k (1 ≤ n ≤ 10^{18}, 2 ≤ k ≤ 10^{18}).
Output
For each query print the minimum number of steps to reach 0 from n in single line.
Example
Input
2
59 3
1000000000000000000 10
Output
8
19
Note
Steps for the first test case are: 59 → 58 → 57 → 19 → 18 → 6 → 2 → 1 → 0.
In the second test case you have to divide n by k 18 times and then decrease n by 1.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int t;
cin >> t;
while (t--) {
long long n, k;
cin >> n >> k;
long long count = 0;
while (n) {
if (n % k == 0) {
n = n / k;
count++;
} else {
count += n % k;
n = n - n % k;
}
}
cout << count << endl;
}
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Let's call some positive integer classy if its decimal representation contains no more than 3 non-zero digits. For example, numbers 4, 200000, 10203 are classy and numbers 4231, 102306, 7277420000 are not.
You are given a segment [L; R]. Count the number of classy integers x such that L ≤ x ≤ R.
Each testcase contains several segments, for each of them you are required to solve the problem separately.
Input
The first line contains a single integer T (1 ≤ T ≤ 10^4) — the number of segments in a testcase.
Each of the next T lines contains two integers L_i and R_i (1 ≤ L_i ≤ R_i ≤ 10^{18}).
Output
Print T lines — the i-th line should contain the number of classy integers on a segment [L_i; R_i].
Example
Input
4
1 1000
1024 1024
65536 65536
999999 1000001
Output
1000
1
0
2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long int sum() { return 0; }
template <typename T, typename... Args>
T sum(T a, Args... args) {
return a + sum(args...);
}
template <typename T1, typename T2>
istream& operator>>(istream& in, pair<T1, T2>& a) {
in >> a.first >> a.second;
return in;
}
template <typename T1, typename T2>
ostream& operator<<(ostream& out, pair<T1, T2> a) {
out << a.first << " " << a.second;
return out;
}
const long long INF = 1e18;
const int32_t M = 1e9 + 7;
const int32_t MM = 998244353;
const long long int N = 200005;
vector<long long int> ans = {INF};
void precal(long long int pos, long long int c, long long int num) {
if (pos == 18) {
ans.push_back(num);
return;
}
precal(pos + 1, c, num * 10);
if (c < 3) {
for (long long int i = 1; i <= 9; i++) {
precal(pos + 1, c + 1, num * 10 + i);
}
}
}
void solve() {
long long int l, r;
cin >> l >> r;
cout << upper_bound(ans.begin(), ans.end(), r) -
lower_bound(ans.begin(), ans.end(), l)
<< "\n";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
precal(0, 0, 0);
sort(ans.begin(), ans.end());
long long int t = 1;
cin >> t;
while (t--) {
solve();
}
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
New Year is getting near. So it's time to change handles on codeforces. Mishka wants to change his handle but in such a way that people would not forget who he is.
To make it work, he only allowed to change letters case. More formally, during one handle change he can choose any segment of his handle [i; i + l - 1] and apply tolower or toupper to all letters of his handle on this segment (more fomally, replace all uppercase letters with corresponding lowercase or vice versa). The length l is fixed for all changes.
Because it is not allowed to change codeforces handle too often, Mishka can perform at most k such operations. What is the minimum value of min(lower, upper) (where lower is the number of lowercase letters, and upper is the number of uppercase letters) can be obtained after optimal sequence of changes?
Input
The first line of the input contains three integers n, k and l (1 ≤ n, k, l ≤ 10^6, l ≤ n) — the length of Mishka's handle, the number of changes and the length of the segment.
The second line of the input contains one string s, consisting of n lowercase and uppercase Latin letters — Mishka's handle.
Output
Print one integer — the minimum value of min(lower, upper) after that Mishka change his handle at most k times in a way described in the problem statement.
Examples
Input
7 1 4
PikMike
Output
0
Input
15 2 2
AaAaAAaaAAAAaaA
Output
2
Input
14 2 6
aBcdEFGHIJklMn
Output
0
Input
9 2 2
aAaAAAaaA
Output
1
### Response
```cpp
#include <bits/stdc++.h>
int n, k, l;
std::vector<int> pref;
std::vector<int> A;
inline int sum(int a, int b) { return pref[b + 1] - pref[a]; }
std::pair<long long, int> withcost(int cost) {
std::vector<std::pair<long long, int> > dp(n + 1);
for (int i = (1); i < (n + 1); ++i) {
int b = std::max(0, i - l);
dp[i] =
std::min(std::make_pair(dp[b].first + cost, dp[b].second + 1),
std::make_pair(dp[i - 1].first + A[i - 1], dp[i - 1].second));
}
return dp[n];
}
int aaa(int cost) { return withcost(cost).first - 1ll * k * cost; }
int solve() {
int left = 0;
int right = 1000000000;
while (left < right) {
int cost = (left + right) / 2;
auto xd = withcost(cost);
if (xd.second > k)
left = cost + 1;
else
right = cost;
}
return aaa(left);
}
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(0);
std::cin >> n >> k >> l;
std::string s;
std::cin >> s;
A.resize(n);
pref.resize(n + 1);
for (int i = 0; i < ((int)(s).size()); ++i)
if (s[i] < 'a') A[i] = 1;
for (int i = 0; i < (n); ++i) pref[i + 1] = pref[i] + A[i];
int ans = solve();
for (int i = 0; i < (n); ++i) A[i] = 1 - A[i];
for (int i = 0; i < (n); ++i) pref[i + 1] = pref[i] + A[i];
ans = std::min(solve(), ans);
std::cout << ans << "\n";
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
Anton is growing a tree in his garden. In case you forgot, the tree is a connected acyclic undirected graph.
There are n vertices in the tree, each of them is painted black or white. Anton doesn't like multicolored trees, so he wants to change the tree such that all vertices have the same color (black or white).
To change the colors Anton can use only operations of one type. We denote it as paint(v), where v is some vertex of the tree. This operation changes the color of all vertices u such that all vertices on the shortest path from v to u have the same color (including v and u). For example, consider the tree
<image>
and apply operation paint(3) to get the following:
<image>
Anton is interested in the minimum number of operation he needs to perform in order to make the colors of all vertices equal.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the number of vertices in the tree.
The second line contains n integers colori (0 ≤ colori ≤ 1) — colors of the vertices. colori = 0 means that the i-th vertex is initially painted white, while colori = 1 means it's initially painted black.
Then follow n - 1 line, each of them contains a pair of integers ui and vi (1 ≤ ui, vi ≤ n, ui ≠ vi) — indices of vertices connected by the corresponding edge. It's guaranteed that all pairs (ui, vi) are distinct, i.e. there are no multiple edges.
Output
Print one integer — the minimum number of operations Anton has to apply in order to make all vertices of the tree black or all vertices of the tree white.
Examples
Input
11
0 0 0 1 1 0 1 0 0 1 1
1 2
1 3
2 4
2 5
5 6
5 7
3 8
3 9
3 10
9 11
Output
2
Input
4
0 0 0 0
1 2
2 3
3 4
Output
0
Note
In the first sample, the tree is the same as on the picture. If we first apply operation paint(3) and then apply paint(6), the tree will become completely black, so the answer is 2.
In the second sample, the tree is already white, so there is no need to apply any operations and the answer is 0.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
inline long long bip(long long x, long long n, long long mod) {
long long res = 1;
while (n) {
if (n & 1) {
res = (res * x) % mod;
}
x = (x * x) % mod;
n >>= 1;
}
return res;
}
const int maxn = 1e9;
const int mod = 998244353;
const int N = 2e5 + 10;
int n, c[N], num[N], k = 1, dist, x = 1;
vector<int> g[N], new_g[N];
void dfs(int v) {
num[v] = k;
for (int to : g[v]) {
if (!num[to] && c[to] == c[v]) {
dfs(to);
}
}
}
void dfs2(int v, int p) {
for (int to : g[v]) {
if (to == p) continue;
if (num[v] != num[to]) {
new_g[num[v]].push_back(num[to]);
new_g[num[to]].push_back(num[v]);
}
dfs2(to, v);
}
}
void dfs3(int v, int p, int d) {
if (d > dist) {
x = v;
dist = d;
}
for (auto to : new_g[v]) {
if (to == p) continue;
dfs3(to, v, d + 1);
}
}
void dfs4(int v, int p, int d) {
dist = max(dist, d);
for (auto to : new_g[v]) {
if (to == p) continue;
dfs4(to, v, d + 1);
}
}
void solve() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> c[i];
for (int i = 1; i < n; i++) {
int x, y;
cin >> x >> y;
g[x].push_back(y), g[y].push_back(x);
}
for (int i = 1; i <= n; i++) {
if (!num[i]) {
dfs(i);
k++;
}
}
dfs2(1, -1);
dfs3(1, -1, 0);
dist = 0;
dfs4(x, -1, 0);
cout << (dist + 1) / 2;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int tt = 1;
while (tt--) {
solve();
cout << '\n';
}
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
The marmots have prepared a very easy problem for this year's HC2 – this one. It involves numbers n, k and a sequence of n positive integers a1, a2, ..., an. They also came up with a beautiful and riveting story for the problem statement. It explains what the input means, what the program should output, and it also reads like a good criminal.
However I, Heidi, will have none of that. As my joke for today, I am removing the story from the statement and replacing it with these two unhelpful paragraphs. Now solve the problem, fools!
Input
The first line of the input contains two space-separated integers n and k (1 ≤ k ≤ n ≤ 2200). The second line contains n space-separated integers a1, ..., an (1 ≤ ai ≤ 104).
Output
Output one number.
Examples
Input
8 5
1 1 1 1 1 1 1 1
Output
5
Input
10 3
16 8 2 4 512 256 32 128 64 1
Output
7
Input
5 1
20 10 50 30 46
Output
10
Input
6 6
6 6 6 6 6 6
Output
36
Input
1 1
100
Output
100
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int num[10005];
void QSort(int num[], int l, int r) {
int i = l;
int j = r;
int key = num[i];
while (i <= j) {
while (num[i] < key) i++;
while (num[j] > key) j--;
if (i <= j) {
swap(num[i], num[j]);
i++;
j--;
}
}
if (l < j) QSort(num, l, j);
if (i < r) QSort(num, i, r);
}
int main() {
int n, k;
cin >> n >> k;
long long ans = 0;
for (int i = 1; i <= n; i++) cin >> num[i];
QSort(num, 1, n);
for (int i = 1; i <= k; i++) {
ans += num[i];
}
cout << ans;
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
Peter likes to travel by train. He likes it so much that on the train he falls asleep.
Once in summer Peter was going by train from city A to city B, and as usual, was sleeping. Then he woke up, started to look through the window and noticed that every railway station has a flag of a particular colour.
The boy started to memorize the order of the flags' colours that he had seen. But soon he fell asleep again. Unfortunately, he didn't sleep long, he woke up and went on memorizing the colours. Then he fell asleep again, and that time he slept till the end of the journey.
At the station he told his parents about what he was doing, and wrote two sequences of the colours that he had seen before and after his sleep, respectively.
Peter's parents know that their son likes to fantasize. They give you the list of the flags' colours at the stations that the train passes sequentially on the way from A to B, and ask you to find out if Peter could see those sequences on the way from A to B, or from B to A. Remember, please, that Peter had two periods of wakefulness.
Peter's parents put lowercase Latin letters for colours. The same letter stands for the same colour, different letters — for different colours.
Input
The input data contains three lines. The first line contains a non-empty string, whose length does not exceed 105, the string consists of lowercase Latin letters — the flags' colours at the stations on the way from A to B. On the way from B to A the train passes the same stations, but in reverse order.
The second line contains the sequence, written by Peter during the first period of wakefulness. The third line contains the sequence, written during the second period of wakefulness. Both sequences are non-empty, consist of lowercase Latin letters, and the length of each does not exceed 100 letters. Each of the sequences is written in chronological order.
Output
Output one of the four words without inverted commas:
* «forward» — if Peter could see such sequences only on the way from A to B;
* «backward» — if Peter could see such sequences on the way from B to A;
* «both» — if Peter could see such sequences both on the way from A to B, and on the way from B to A;
* «fantasy» — if Peter could not see such sequences.
Examples
Input
atob
a
b
Output
forward
Input
aaacaaa
aca
aa
Output
both
Note
It is assumed that the train moves all the time, so one flag cannot be seen twice. There are no flags at stations A and B.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
char mainstr[111111];
char substr1[111];
char substr2[111];
int main() {
while (scanf("%s %s %s", mainstr, substr1, substr2) != EOF) {
bool flag1 = false, flag2 = false;
int len = strlen(mainstr);
int len1 = strlen(substr1);
int len2 = strlen(substr2);
char *pos = search(mainstr, mainstr + len, substr1, substr1 + len1);
if (pos != mainstr + len && search(pos + len1, mainstr + len, substr2,
substr2 + len2) != mainstr + len)
flag1 = true;
reverse(mainstr, mainstr + len);
pos = search(mainstr, mainstr + len, substr1, substr1 + len1);
if (pos != mainstr + len && search(pos + len1, mainstr + len, substr2,
substr2 + len2) != mainstr + len)
flag2 = true;
if (flag1 && flag2)
printf("both\n");
else if (flag1)
printf("forward\n");
else if (flag2)
printf("backward\n");
else
printf("fantasy\n");
}
return 0;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
You are given a string s of length n. Does a tree with n vertices that satisfies the following conditions exist?
* The vertices are numbered 1,2,..., n.
* The edges are numbered 1,2,..., n-1, and Edge i connects Vertex u_i and v_i.
* If the i-th character in s is `1`, we can have a connected component of size i by removing one edge from the tree.
* If the i-th character in s is `0`, we cannot have a connected component of size i by removing any one edge from the tree.
If such a tree exists, construct one such tree.
Constraints
* 2 \leq n \leq 10^5
* s is a string of length n consisting of `0` and `1`.
Input
Input is given from Standard Input in the following format:
s
Output
If a tree with n vertices that satisfies the conditions does not exist, print `-1`.
If a tree with n vertices that satisfies the conditions exist, print n-1 lines. The i-th line should contain u_i and v_i with a space in between. If there are multiple trees that satisfy the conditions, any such tree will be accepted.
Examples
Input
1111
Output
-1
Input
1110
Output
1 2
2 3
3 4
Input
1010
Output
1 2
1 3
1 4
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
char s[100000 + 233];
int main(){
scanf("%s",s+1);
int n = strlen(s+1);
bool bad = s[n]-'0';
for(int i=1;i<n;i++){
if(s[i]!=s[n-i])bad = 1;
}
if(s[1]=='0')bad = 1;
s[1] = '0';
if(bad){
puts("-1");
return 0;
}
int last = 1;
for(int i=2;i<=n;i++){
if(s[i-1]=='1'){
printf("%d %d\n",last,i);
last = i;
}
else{
printf("%d %d\n",last,i);
}
}
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
You are given an strictly convex polygon with n vertices. It is guaranteed that no three points are collinear. You would like to take a maximum non intersecting path on the polygon vertices that visits each point at most once.
More specifically your path can be represented as some sequence of distinct polygon vertices. Your path is the straight line segments between adjacent vertices in order. These segments are not allowed to touch or intersect each other except at the vertices in your sequence.
Given the polygon, print the maximum length non-intersecting path that visits each point at most once.
Input
The first line of input will contain a single integer n (2 ≤ n ≤ 2 500), the number of points.
The next n lines will contain two integers xi, yi (|xi|, |yi| ≤ 109), denoting the coordinates of the i-th vertex.
It is guaranteed that these points are listed in clockwise order.
Output
Print a single floating point number, representing the longest non-intersecting path that visits the vertices at most once.
Your answer will be accepted if it has absolute or relative error at most 10 - 9. More specifically, if your answer is a and the jury answer is b, your answer will be accepted if <image>.
Example
Input
4
0 0
0 1
1 1
1 0
Output
3.4142135624
Note
One optimal path is to visit points 0,1,3,2 in order.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct node {
int x, y;
node() {}
node(int X, int Y) { x = X, y = Y; }
} s[2505];
int n;
double dp[2505][2505][2];
double dis(node u, node v) {
return sqrt(1.0 * (u.x - v.x) * (u.x - v.x) +
1.0 * (u.y - v.y) * (u.y - v.y));
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d %d", &s[i].x, &s[i].y);
for (int len = 2; len <= n; len++)
for (int i = 0; i < n; i++) {
int j = (i + len - 1) % n;
dp[i][j][0] = max(dp[(i + 1) % n][j][0] + dis(s[i], s[(i + 1) % n]),
dp[(i + 1) % n][j][1] + dis(s[i], s[j]));
dp[i][j][1] =
max(dp[i][(j - 1 + n) % n][0] + dis(s[i], s[j]),
dp[i][(j - 1 + n) % n][1] + dis(s[(j - 1 + n) % n], s[j]));
}
double ans = 0;
for (int i = 0; i < n; i++)
ans = max(ans, max(dp[i][(i - 1 + n) % n][0], dp[i][(i - 1 + n) % n][1]));
printf("%.10f", ans);
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
After their adventure with the magic mirror Kay and Gerda have returned home and sometimes give free ice cream to kids in the summer.
At the start of the day they have x ice cream packs. Since the ice cream is free, people start standing in the queue before Kay and Gerda's house even in the night. Each person in the queue wants either to take several ice cream packs for himself and his friends or to give several ice cream packs to Kay and Gerda (carriers that bring ice cream have to stand in the same queue).
If a carrier with d ice cream packs comes to the house, then Kay and Gerda take all his packs. If a child who wants to take d ice cream packs comes to the house, then Kay and Gerda will give him d packs if they have enough ice cream, otherwise the child will get no ice cream at all and will leave in distress.
Kay wants to find the amount of ice cream they will have after all people will leave from the queue, and Gerda wants to find the number of distressed kids.
Input
The first line contains two space-separated integers n and x (1 ≤ n ≤ 1000, 0 ≤ x ≤ 109).
Each of the next n lines contains a character '+' or '-', and an integer di, separated by a space (1 ≤ di ≤ 109). Record "+ di" in i-th line means that a carrier with di ice cream packs occupies i-th place from the start of the queue, and record "- di" means that a child who wants to take di packs stands in i-th place.
Output
Print two space-separated integers — number of ice cream packs left after all operations, and number of kids that left the house in distress.
Examples
Input
5 7
+ 5
- 10
- 20
+ 40
- 20
Output
22 1
Input
5 17
- 16
- 2
- 98
+ 100
- 98
Output
3 2
Note
Consider the first sample.
1. Initially Kay and Gerda have 7 packs of ice cream.
2. Carrier brings 5 more, so now they have 12 packs.
3. A kid asks for 10 packs and receives them. There are only 2 packs remaining.
4. Another kid asks for 20 packs. Kay and Gerda do not have them, so the kid goes away distressed.
5. Carrier bring 40 packs, now Kay and Gerda have 42 packs.
6. Kid asks for 20 packs and receives them. There are 22 packs remaining.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
long long x, num;
while (cin >> n >> x) {
num = 0;
for (int i = 1; i <= n; i++) {
char str[10];
int k;
cin >> str >> k;
if (str[0] == '+') {
x += k;
} else {
if (k <= x)
x -= k;
else {
num++;
}
}
}
cout << x << " " << num << endl;
}
return 0;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
Let's call beauty of an array b_1, b_2, …, b_n (n > 1) — min_{1 ≤ i < j ≤ n} |b_i - b_j|.
You're given an array a_1, a_2, … a_n and a number k. Calculate the sum of beauty over all subsequences of the array of length exactly k. As this number can be very large, output it modulo 998244353.
A sequence a is a subsequence of an array b if a can be obtained from b by deletion of several (possibly, zero or all) elements.
Input
The first line contains integers n, k (2 ≤ k ≤ n ≤ 1000).
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 10^5).
Output
Output one integer — the sum of beauty over all subsequences of the array of length exactly k. As this number can be very large, output it modulo 998244353.
Examples
Input
4 3
1 7 3 5
Output
8
Input
5 5
1 10 100 1000 10000
Output
9
Note
In the first example, there are 4 subsequences of length 3 — [1, 7, 3], [1, 3, 5], [7, 3, 5], [1, 7, 5], each of which has beauty 2, so answer is 8.
In the second example, there is only one subsequence of length 5 — the whole array, which has the beauty equal to |10-1| = 9.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, ch = getchar();
bool fg = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') fg = 0;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return fg ? x : -x;
}
const int MAXN = 1005, mod = 998244353;
int a[MAXN], dp[MAXN][MAXN];
int main() {
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
int mx = a[n] / (k - 1) + 1;
int ans = 0;
for (int i = 1; i <= k; i++) dp[0][i] = -1;
int last = 0;
for (int x = mx; x > 0; x--) {
int cur = 0;
for (int i = 1; i <= n; i++) {
while (cur + 1 < i && a[i] - a[cur + 1] >= x) cur++;
for (int j = 1; j <= k; j++) {
dp[i][j] = (dp[cur][j - 1] + 1 + dp[i - 1][j]) % mod;
}
}
if (~dp[n][k]) {
ans = (ans + (long long)(dp[n][k] + 1 - last) * x) % mod;
last = dp[n][k] + 1;
}
}
cout << (ans + mod) % mod << endl;
return 0;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
Eighth-grader Vova is on duty today in the class. After classes, he went into the office to wash the board, and found on it the number n. He asked what is this number and the teacher of mathematics Inna Petrovna answered Vova that n is the answer to the arithmetic task for first-graders. In the textbook, a certain positive integer x was given. The task was to add x to the sum of the digits of the number x written in decimal numeral system.
Since the number n on the board was small, Vova quickly guessed which x could be in the textbook. Now he wants to get a program which will search for arbitrary values of the number n for all suitable values of x or determine that such x does not exist. Write such a program for Vova.
Input
The first line contains integer n (1 ≤ n ≤ 109).
Output
In the first line print one integer k — number of different values of x satisfying the condition.
In next k lines print these values in ascending order.
Examples
Input
21
Output
1
15
Input
20
Output
0
Note
In the first test case x = 15 there is only one variant: 15 + 1 + 5 = 21.
In the second test case there are no such x.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)2e9 + 10;
const int mod = (int)1e9 + 7;
const int N = (int)1e6 + 10;
const long long LLINF = (long long)3e18 + 10;
const long double pi = acos(-1.0);
const long double eps = (long double)1e-9;
template <typename T1, typename T2>
bool umin(T1 &x, T2 y) {
if (x > y) return x = y, true;
return false;
}
template <typename T1, typename T2>
bool umax(T1 &x, T2 y) {
if (x < y) return x = y, true;
return false;
}
template <typename T>
T getint() {
char c = getchar();
T p = 1, x = 0;
while (c == ' ' || c == '\n') c = getchar();
if (c == '-') p = -1, c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return x * p;
}
bool check(int x, int n) {
int y = x;
while (y > 0) {
x += y % 10;
y /= 10;
}
return x == n;
}
int main() {
srand(time(NULL));
ios_base::sync_with_stdio(0);
int n;
cin >> n;
vector<int> ans;
for (int x = n; x >= max(1, n - 10000); --x) {
if (check(x, n)) ans.push_back(x);
}
cout << ans.size() << '\n';
sort((ans).begin(), (ans).end());
for (int i = 0; i < ans.size(); ++i) cout << ans[i] << '\n';
return 0;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
Indian summer is such a beautiful time of the year! A girl named Alyona is walking in the forest and picking a bouquet from fallen leaves. Alyona is very choosy — she doesn't take a leaf if it matches the color and the species of the tree of one of the leaves she already has. Find out how many leaves Alyona has picked.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the number of leaves Alyona has found. The next n lines contain the leaves' descriptions. Each leaf is characterized by the species of the tree it has fallen from and by the color. The species of the trees and colors are given in names, consisting of no more than 10 lowercase Latin letters. A name can not be an empty string. The species of a tree and the color are given in each line separated by a space.
Output
Output the single number — the number of Alyona's leaves.
Examples
Input
5
birch yellow
maple red
birch yellow
maple yellow
maple green
Output
4
Input
3
oak yellow
oak yellow
oak yellow
Output
1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, ans;
struct leaves {
string tree, color;
} l[110];
int main() {
cin >> n;
ans = n;
for (int i = 0; i < n; ++i) {
cin >> l[i].tree >> l[i].color;
for (int j = 0; j < i; ++j) {
if (l[j].color == l[i].color && l[j].tree == l[i].tree) {
--ans;
break;
}
}
}
cout << ans << endl;
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
The Berland capital is shaken with three bold crimes committed by the Pihsters, a notorious criminal gang.
The Berland capital's map is represented by an n × m rectangular table. Each cell of the table on the map represents some districts of the capital.
The capital's main detective Polycarpus took a map and marked there the districts where the first three robberies had been committed as asterisks. Deduction tells Polycarpus that the fourth robbery will be committed in such district, that all four robbed districts will form the vertices of some rectangle, parallel to the sides of the map.
Polycarpus is good at deduction but he's hopeless at math. So he asked you to find the district where the fourth robbery will be committed.
Input
The first line contains two space-separated integers n and m (2 ≤ n, m ≤ 100) — the number of rows and columns in the table, correspondingly.
Each of the next n lines contains m characters — the description of the capital's map. Each character can either be a "." (dot), or an "*" (asterisk). A character equals "*" if the corresponding district has been robbed. Otherwise, it equals ".".
It is guaranteed that the map has exactly three characters "*" and we can always find the fourth district that meets the problem requirements.
Output
Print two integers — the number of the row and the number of the column of the city district that is the fourth one to be robbed. The rows are numbered starting from one from top to bottom and the columns are numbered starting from one from left to right.
Examples
Input
3 2
.*
..
**
Output
1 1
Input
3 3
*.*
*..
...
Output
2 3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, A[3][2] = {};
cin >> n >> m;
string s;
for (int x = 0, i = 0; i < n; i++) {
cin >> s;
for (int j = 0; j < s.length(); j++) {
if (s[j] == '*') {
A[x][0] = i + 1;
A[x][1] = j + 1;
x++;
}
}
}
if (A[0][0] == A[1][0]) {
if (A[2][1] == A[0][1]) {
cout << A[2][0] << " " << A[1][1];
} else {
cout << A[2][0] << " " << A[0][1];
}
} else {
if (A[0][1] == A[2][1]) {
cout << A[0][0] << " " << A[1][1];
} else {
cout << A[0][0] << " " << A[2][1];
}
}
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
The Squareland national forest is divided into equal 1 × 1 square plots aligned with north-south and east-west directions. Each plot can be uniquely described by integer Cartesian coordinates (x, y) of its south-west corner.
Three friends, Alice, Bob, and Charlie are going to buy three distinct plots of land A, B, C in the forest. Initially, all plots in the forest (including the plots A, B, C) are covered by trees. The friends want to visit each other, so they want to clean some of the plots from trees. After cleaning, one should be able to reach any of the plots A, B, C from any other one of those by moving through adjacent cleared plots. Two plots are adjacent if they share a side.
<image> For example, A=(0,0), B=(1,1), C=(2,2). The minimal number of plots to be cleared is 5. One of the ways to do it is shown with the gray color.
Of course, the friends don't want to strain too much. Help them find out the smallest number of plots they need to clean from trees.
Input
The first line contains two integers x_A and y_A — coordinates of the plot A (0 ≤ x_A, y_A ≤ 1000). The following two lines describe coordinates (x_B, y_B) and (x_C, y_C) of plots B and C respectively in the same format (0 ≤ x_B, y_B, x_C, y_C ≤ 1000). It is guaranteed that all three plots are distinct.
Output
On the first line print a single integer k — the smallest number of plots needed to be cleaned from trees. The following k lines should contain coordinates of all plots needed to be cleaned. All k plots should be distinct. You can output the plots in any order.
If there are multiple solutions, print any of them.
Examples
Input
0 0
1 1
2 2
Output
5
0 0
1 0
1 1
1 2
2 2
Input
0 0
2 0
1 1
Output
4
0 0
1 0
1 1
2 0
Note
The first example is shown on the picture in the legend.
The second example is illustrated with the following image:
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long INFll = 1ll * 1000000009 * 1000000009;
int dist(int x1, int y1, int x2, int y2) { return abs(x2 - x1) + abs(y2 - y1); }
set<pair<int, int> > calc(int x, int y, int x1, int y1, int x2, int y2, int x3,
int y3) {
set<pair<int, int> > ans;
int currx = x, curry = y;
while (currx != x1) {
ans.insert({currx, curry});
if (x1 > currx)
currx++;
else
currx--;
}
while (curry != y1) {
ans.insert({currx, curry});
if (y1 > curry)
curry++;
else
curry--;
}
currx = x, curry = y;
while (currx != x2) {
ans.insert({currx, curry});
if (x2 > currx)
currx++;
else
currx--;
}
while (curry != y2) {
ans.insert({currx, curry});
if (y2 > curry)
curry++;
else
curry--;
}
currx = x, curry = y;
while (currx != x3) {
ans.insert({currx, curry});
if (x3 > currx)
currx++;
else
currx--;
}
while (curry != y3) {
ans.insert({currx, curry});
if (y3 > curry)
curry++;
else
curry--;
}
ans.insert({x1, y1});
ans.insert({x2, y2});
ans.insert({x3, y3});
return ans;
}
int main() {
int xa, ya, xb, yb, xc, yc;
set<pair<int, int> > res;
cin >> xa >> ya >> xb >> yb >> xc >> yc;
int x, y, mx = 1000000009;
for (int i = 0; i <= 1000; i++)
for (int j = 0; j <= 1000; j++) {
int temp = dist(i, j, xa, ya) + dist(i, j, xb, yb) + dist(i, j, xc, yc);
if (temp < mx) {
mx = temp;
x = i;
y = j;
}
}
res = calc(x, y, xa, ya, xb, yb, xc, yc);
cout << res.size() << endl;
for (auto it = res.begin(); it != res.end(); ++it)
cout << it->first << ' ' << it->second << endl;
cout << endl;
;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Your classmate, whom you do not like because he is boring, but whom you respect for his intellect, has two strings: s of length n and t of length m.
A sequence p_1, p_2, …, p_m, where 1 ≤ p_1 < p_2 < … < p_m ≤ n, is called beautiful, if s_{p_i} = t_i for all i from 1 to m. The width of a sequence is defined as max_{1 ≤ i < m} \left(p_{i + 1} - p_i\right).
Please help your classmate to identify the beautiful sequence with the maximum width. Your classmate promised you that for the given strings s and t there is at least one beautiful sequence.
Input
The first input line contains two integers n and m (2 ≤ m ≤ n ≤ 2 ⋅ 10^5) — the lengths of the strings s and t.
The following line contains a single string s of length n, consisting of lowercase letters of the Latin alphabet.
The last line contains a single string t of length m, consisting of lowercase letters of the Latin alphabet.
It is guaranteed that there is at least one beautiful sequence for the given strings.
Output
Output one integer — the maximum width of a beautiful sequence.
Examples
Input
5 3
abbbc
abc
Output
3
Input
5 2
aaaaa
aa
Output
4
Input
5 5
abcdf
abcdf
Output
1
Input
2 2
ab
ab
Output
1
Note
In the first example there are two beautiful sequences of width 3: they are \{1, 2, 5\} and \{1, 4, 5\}.
In the second example the beautiful sequence with the maximum width is \{1, 5\}.
In the third example there is exactly one beautiful sequence — it is \{1, 2, 3, 4, 5\}.
In the fourth example there is exactly one beautiful sequence — it is \{1, 2\}.
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
#define io ios::sync_with_stdio(0);cin.tie(0);cout.tie(0)
int main()
{
io;
long long t,i,j,k,l,n,r,m,p,q,a,b,c,d;
// cin>>a>>b>>c>>d;
cin>>n>>m; long long zzz[m][6];
string z,zz;j=0;
cin>>z>>zz;
for(i=0;i<m;i++)
{
if(zz[i]==z[j])
zzz[i][0]=j;
else
i--;
j++;
}
j=n-1;
for(i=m-1;i>=0;i--)
{
if(zz[i]==z[j])
zzz[i][1]=j;
else i++;
j--;
}l=0;
for(i=1;i<m;i++)
{
// cout<<zzz[i-1][0]<<" "<<zzz[i][1]<<endl;
l=max(l,abs(zzz[i-1][0]-zzz[i][1]));
}
cout<<l<<endl;
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
The New Year is coming! That's why many people today are busy preparing New Year presents. Vasily the Programmer is no exception.
Vasily knows that the best present is (no, it's not a contest) money. He's put n empty wallets from left to right in a row and decided how much money to put in what wallet. Vasily decided to put ai coins to the i-th wallet from the left.
Vasily is a very busy man, so the money are sorted into the bags by his robot. Initially, the robot stands by the leftmost wallet in the row. The robot can follow instructions of three types: go to the wallet that is to the left of the current one (if such wallet exists), go to the wallet that is to the right of the current one (if such wallet exists), put a coin to the current wallet. Due to some technical malfunctions the robot cannot follow two "put a coin" instructions in a row.
Vasily doesn't want to wait for long, so he wants to write a program for the robot that contains at most 106 operations (not necessarily minimum in length) the robot can use to put coins into the wallets. Help him.
Input
The first line contains integer n (2 ≤ n ≤ 300) — the number of wallets. The next line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 300).
It is guaranteed that at least one ai is positive.
Output
Print the sequence that consists of k (1 ≤ k ≤ 106) characters, each of them equals: "L", "R" or "P". Each character of the sequence is an instruction to the robot. Character "L" orders to move to the left, character "R" orders to move to the right, character "P" orders the robot to put a coin in the wallet. The robot is not allowed to go beyond the wallet line. In other words, you cannot give instructions "L" if the robot is at wallet 1, or "R" at wallet n.
As a result of the performed operations, the i-th wallet from the left must contain exactly ai coins. If there are multiple answers, you can print any of them.
Examples
Input
2
1 2
Output
PRPLRP
Input
4
0 2 0 2
Output
RPRRPLLPLRRRP
### Response
```cpp
#include <bits/stdc++.h>
int main() {
int n;
scanf("%d", &n);
int a[300 + 1];
int i;
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
int can_end = 0;
i = 0;
int j;
int find;
while (i < n && !can_end) {
while (1) {
if (a[i] > 0) {
printf("P");
a[i]--;
}
if (a[i] == 0 && a[i + 1] > 0 && i + 2 < n) {
break;
}
if (i == n - 1 && a[i] > 0) {
printf("L");
i--;
continue;
}
find = 0;
for (j = i; j < n; j++) {
if (a[j] > 0) {
find = 1;
break;
}
}
if (!find) {
can_end = 1;
break;
}
if (!(a[i] == 0 && a[i + 1] == 0 && i + 2 >= n)) {
printf("R");
}
if (a[i + 1] > 0) {
printf("P");
a[i + 1]--;
}
find = 0;
for (j = i; j < n; j++) {
if (a[j] > 0) {
find = 1;
}
}
if (!find) {
can_end = 1;
break;
}
if (a[i] == 0 && a[i + 1] == 0) {
if (i + 2 < n) printf("R");
break;
} else {
printf("L");
}
}
if (a[i] == 0 && a[i + 1] > 0 && i + 2 < n) {
i++;
printf("R");
} else {
i += 2;
}
}
printf("\n");
return 0;
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
Professor Matsuzaki is a scientist studying the truth of the universe. Life, the universe, all the answers are said to be 42, but Professor Matsuzaki thinks that this alone is not enough to elucidate the truth of the universe. Professor Matsuzaki believes that the truth of the universe is represented by a function consisting of two parameters, and 42 is just one of them.
The function M (N, P) defined by Professor Matsuzaki selects two prime numbers larger than N (the same number can be two) and sums them, in order from the smallest number. Represents the number that appears in the Pth position when arranged. Here, there are numbers that can be represented by two or more sums, but such numbers are arranged in the same number as the number of combinations of sums.
As an example, consider the case of N = 0. In this case, two are selected from all the prime numbers and summed. Considering the smallest number among such sums, it is permissible to select the same number twice, which shows that 2 + 2 = 4. That is, M (0, 1) = 4. The next smallest number is 2 + 3 = 5, so M (0, 2) = 5. Considering in the same way, it can be seen that the sums are arranged as 4, 5, 6, 7, 8, 9, 10, 10, 12, 13, 14, 14, 16, .... That is, for example, M (0, 9) = 12.
Considering the case of N = 10 in the same way, in this case, two prime numbers greater than 10 {11, 13, 17, 19, ...} are selected, and the sums obtained are arranged in ascending order. And 22, 24, 26, 28, 30, 30, 32, ...
Your job is to write a program that calculates M (N, P) given N and P.
Input
The input consists of multiple datasets. The dataset is one line, given two integers N (0 ≤ N ≤ 100,000) and P (1 ≤ P ≤ 100) separated by a single space.
The end of the input is indicated by a single line containing two blank-separated -1s.
Output
For each dataset, output the value of M (N, P) on one line. The output must not contain extra blanks or line breaks.
Sample Input
0 55
0 1
0 2
0 3
10 1
10 2
10 3
10 4
10 5
10 6
11 1
11 2
11 3
100000 100
-1 -1
Output for the Sample Input
42
Four
Five
6
twenty two
twenty four
26
28
30
30
26
30
32
200274
Example
Input
0 55
0 1
0 2
0 3
10 1
10 2
10 3
10 4
10 5
10 6
11 1
11 2
11 3
100000 100
-1 -1
Output
42
4
5
6
22
24
26
28
30
30
26
30
32
200274
### Response
```cpp
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
bool isPrime(int n) {
if (n == 1) return false;
for (int i = 2; i*i <= n; ++i) {
if (n % i == 0) return false;
}
return true;
}
//bool f[10000000] = {0};
int main() {
int N, p;
while ( cin >> N >> p, N != -1 || p != -1 ) {
// fill(&f[0], &f[0]+10000000, false);
int b = -1;
vector<int> v;
for (int i = N+1; ; ++i) {
if (isPrime(i)) {
v.push_back(i);
if (v.size() > p+1) break;
}
}
vector<int> a;
for (int i = 0; i < v.size(); ++i) {
for (int j = i; j < v.size(); ++j) {
// if (!f[v[i]+v[j]]) {
a.push_back(v[i]+v[j]);
// f[v[i]+v[j]] = true;
// }
}
}
sort( a.begin(), a.end() );
// a.erase( unique(a.begin(), a.end()), a.end() );
cout << a[p-1] << endl;
}
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
You are given a permutation a consisting of n numbers 1, 2, ..., n (a permutation is an array in which each element from 1 to n occurs exactly once).
You can perform the following operation: choose some subarray (contiguous subsegment) of a and rearrange the elements in it in any way you want. But this operation cannot be applied to the whole array.
For example, if a = [2, 1, 4, 5, 3] and we want to apply the operation to the subarray a[2, 4] (the subarray containing all elements from the 2-nd to the 4-th), then after the operation, the array can become a = [2, 5, 1, 4, 3] or, for example, a = [2, 1, 5, 4, 3].
Your task is to calculate the minimum number of operations described above to sort the permutation a in ascending order.
Input
The first line contains a single integer t (1 ≤ t ≤ 2000) — the number of test cases.
The first line of the test case contains a single integer n (3 ≤ n ≤ 50) — the number of elements in the permutation.
The second line of the test case contains n distinct integers from 1 to n — the given permutation a.
Output
For each test case, output a single integer — the minimum number of operations described above to sort the array a in ascending order.
Example
Input
3
4
1 3 2 4
3
1 2 3
5
2 1 4 5 3
Output
1
0
2
Note
In the explanations, a[i, j] defines the subarray of a that starts from the i-th element and ends with the j-th element.
In the first test case of the example, you can select the subarray a[2, 3] and swap the elements in it.
In the second test case of the example, the permutation is already sorted, so you don't need to apply any operations.
In the third test case of the example, you can select the subarray a[3, 5] and reorder the elements in it so a becomes [2, 1, 3, 4, 5], and then select the subarray a[1, 2] and swap the elements in it, so a becomes [1, 2, 3, 4, 5].
### Response
```cpp
#include <bits/stdc++.h>
#define ll long long int
#define pb push_back
#define IM INT_MAX
using namespace std;
const ll INF = 1e16;
const ll mod = 1e9+7;
const ll maxn = 4e6 + 5;
void solve(){
int n;
cin>>n;
vector<int> arr(n);
for(int i=0; i<n ;i++){
cin>>arr[i];
}
int f1 = 0;
for(int i=0; i<n-1;i++){
if(arr[i+1]>=arr[i]){}
else{
f1=1;
}
}
if(!f1){
cout<<0<<"\n";
return;
}
if(arr[0]==1 || arr[n-1]==n){
cout<<1<<"\n";
}
else if(arr[0]==n && arr[n-1]==1){
cout<<3<<"\n";
}
else{
cout<<2<<"\n";
}
}
int main() {
int t;
scanf("%d",&t);
while(t--) solve();
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
Two players play a simple game. Each player is provided with a box with balls. First player's box contains exactly n1 balls and second player's box contains exactly n2 balls. In one move first player can take from 1 to k1 balls from his box and throw them away. Similarly, the second player can take from 1 to k2 balls from his box in his move. Players alternate turns and the first player starts the game. The one who can't make a move loses. Your task is to determine who wins if both players play optimally.
Input
The first line contains four integers n1, n2, k1, k2. All numbers in the input are from 1 to 50.
This problem doesn't have subproblems. You will get 3 points for the correct submission.
Output
Output "First" if the first player wins and "Second" otherwise.
Examples
Input
2 2 1 2
Output
Second
Input
2 1 1 1
Output
First
Note
Consider the first sample test. Each player has a box with 2 balls. The first player draws a single ball from his box in one move and the second player can either take 1 or 2 balls from his box in one move. No matter how the first player acts, the second player can always win if he plays wisely.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, x, y;
cin >> a >> b >> x >> y;
if (a > b) {
cout << "First";
return 0;
}
cout << "Second";
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
Berland has managed to repel the flatlanders' attack and is now starting the counter attack.
Flatland has n cities, numbered from 1 to n, and some pairs of them are connected by bidirectional roads. The Flatlandian maps show roads between cities if and only if there is in fact no road between this pair of cities (we do not know whether is it a clever spy-proof strategy or just saving ink). In other words, if two cities are connected by a road on a flatland map, then there is in fact no road between them. The opposite situation is also true: if two cities are not connected by a road on a flatland map, then in fact, there is a road between them.
The berlanders got hold of a flatland map. Now Vasya the Corporal is commissioned by General Touristov to find all such groups of flatland cities, that in each group of cities you can get from any city to any other one, moving along the actual roads. Also the cities from different groups are unreachable from each other, moving along the actual roads. Indeed, destroying such groups one by one is much easier than surrounding all Flatland at once!
Help the corporal complete this task and finally become a sergeant! Don't forget that a flatland map shows a road between cities if and only if there is in fact no road between them.
Input
The first line contains two space-separated integers n and m (1 ≤ n ≤ 5·105, 0 ≤ m ≤ 106) — the number of cities and the number of roads marked on the flatland map, correspondingly.
Next m lines contain descriptions of the cities on the map. The i-th line contains two integers ai and bi (1 ≤ ai, bi ≤ n, ai ≠ bi) — the numbers of cities that are connected by the i-th road on the flatland map.
It is guaranteed that each pair of cities occurs in the input no more than once.
Output
On the first line print number k — the number of groups of cities in Flatland, such that in each group you can get from any city to any other one by flatland roads. At the same time, the cities from different groups should be unreachable by flatland roads.
On each of the following k lines first print ti (1 ≤ ti ≤ n) — the number of vertexes in the i-th group. Then print space-separated numbers of cities in the i-th group.
The order of printing groups and the order of printing numbers in the groups does not matter. The total sum ti for all k groups must equal n.
Examples
Input
4 4
1 2
1 3
4 2
4 3
Output
2
2 1 4
2 2 3
Input
3 1
1 2
Output
1
3 1 2 3
Note
In the first sample there are roads only between pairs of cities 1-4 and 2-3.
In the second sample there is no road between cities 1 and 2, but still you can get from one city to the other one through city number 3.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 100;
template <typename T>
inline T read() {
T s = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
s = (s << 3) + (s << 1) + ch - 48;
ch = getchar();
}
return s * f;
}
set<int> st;
int vis[N];
int color[N];
vector<int> v[N], one[N];
int tot = 0;
int main() {
int n = read<int>(), m = read<int>();
for (int i = 1; i <= m; ++i) {
int x = read<int>(), y = read<int>();
one[x].push_back(y);
one[y].push_back(x);
}
for (int i = 1; i <= n; ++i) {
st.insert(i);
sort(one[i].begin(), one[i].end());
one[i].push_back(1e6);
}
queue<int> q;
int ans = 0;
for (int i = 1; i <= n; ++i) {
if (vis[i]) continue;
q.push(i);
st.erase(i);
++ans;
color[i] = ans;
v[ans].push_back(i);
while (!q.empty()) {
int now = q.front();
q.pop();
if (vis[now]) continue;
vis[now] = 1;
for (auto it = st.begin(); it != st.end();) {
if (vis[*it]) continue;
auto item = lower_bound(one[now].begin(), one[now].end(), *it);
if (item == one[i].end() || *item != *it) {
color[*it] = color[now];
v[color[now]].push_back(*it);
q.push(*it);
it = st.erase(it);
} else
++it;
}
}
}
printf("%d\n", ans);
for (int i = 1; i <= ans; ++i) {
printf("%d", v[i].size());
for (auto to : v[i]) {
printf(" %d", to);
}
printf("\n");
}
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
Barney lives in NYC. NYC has infinite number of intersections numbered with positive integers starting from 1. There exists a bidirectional road between intersections i and 2i and another road between i and 2i + 1 for every positive integer i. You can clearly see that there exists a unique shortest path between any two intersections.
<image>
Initially anyone can pass any road for free. But since SlapsGiving is ahead of us, there will q consecutive events happen soon. There are two types of events:
1. Government makes a new rule. A rule can be denoted by integers v, u and w. As the result of this action, the passing fee of all roads on the shortest path from u to v increases by w dollars.
2. Barney starts moving from some intersection v and goes to intersection u where there's a girl he wants to cuddle (using his fake name Lorenzo Von Matterhorn). He always uses the shortest path (visiting minimum number of intersections or roads) between two intersections.
Government needs your calculations. For each time Barney goes to cuddle a girl, you need to tell the government how much money he should pay (sum of passing fee of all roads he passes).
Input
The first line of input contains a single integer q (1 ≤ q ≤ 1 000).
The next q lines contain the information about the events in chronological order. Each event is described in form 1 v u w if it's an event when government makes a new rule about increasing the passing fee of all roads on the shortest path from u to v by w dollars, or in form 2 v u if it's an event when Barnie goes to cuddle from the intersection v to the intersection u.
1 ≤ v, u ≤ 1018, v ≠ u, 1 ≤ w ≤ 109 states for every description line.
Output
For each event of second type print the sum of passing fee of all roads Barney passes in this event, in one line. Print the answers in chronological order of corresponding events.
Example
Input
7
1 3 4 30
1 4 1 2
1 3 6 8
2 4 3
1 6 1 40
2 3 7
2 2 4
Output
94
0
32
Note
In the example testcase:
Here are the intersections used:
<image>
1. Intersections on the path are 3, 1, 2 and 4.
2. Intersections on the path are 4, 2 and 1.
3. Intersections on the path are only 3 and 6.
4. Intersections on the path are 4, 2, 1 and 3. Passing fee of roads on the path are 32, 32 and 30 in order. So answer equals to 32 + 32 + 30 = 94.
5. Intersections on the path are 6, 3 and 1.
6. Intersections on the path are 3 and 7. Passing fee of the road between them is 0.
7. Intersections on the path are 2 and 4. Passing fee of the road between them is 32 (increased by 30 in the first event and by 2 in the second).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const double PI = 3.1415926535897932384626433832795;
const double eps = 1e-9;
const int null = 10000;
long long int q;
vector<long long int> v[2007];
long long int up(long long int a, long long int b) {
while (a != b) {
if (a > b)
a = a >> 1;
else
b = b >> 1;
}
return a;
}
void sol() {
long long int i, j, s, t, a, b, x, fr = 0, ua, ux, ub, ta, tb;
scanf("%I64d", &q);
for (i = 0; i < q; i++) {
scanf("%I64d%I64d%I64d", &t, &a, &b);
if (t == 1) {
scanf("%I64d", &x);
v[fr].push_back(up(a, b));
v[fr].push_back(a);
v[fr].push_back(x);
v[fr + 1].push_back(up(a, b));
v[fr + 1].push_back(b);
v[fr + 1].push_back(x);
fr += 2;
} else {
s = 0;
ta = a;
tb = b;
ua = up(a, b);
ub = up(a, b);
for (j = 0; j < fr; j++) {
a = ta;
b = tb;
ux = v[j][0];
x = v[j][1];
while (a != ua && x != ux) {
if (a > x) {
a = a >> 1;
} else if (a < x) {
x = x >> 1;
} else {
a = a >> 1;
x = x >> 1;
s += v[j][2];
}
}
ux = v[j][0];
x = v[j][1];
while (b != ub && x != ux) {
if (b > x) {
b = b >> 1;
} else if (b < x) {
x = x >> 1;
} else {
b = b >> 1;
x = x >> 1;
s += v[j][2];
}
}
}
printf("%I64d\n", s);
}
}
}
int main() {
#pragma comment(linker, "/STACK:268435456")
sol();
return 0;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
Panic is rising in the committee for doggo standardization — the puppies of the new brood have been born multi-colored! In total there are 26 possible colors of puppies in the nature and they are denoted by letters from 'a' to 'z' inclusive.
The committee rules strictly prohibit even the smallest diversity between doggos and hence all the puppies should be of the same color. Thus Slava, the committee employee, has been assigned the task to recolor some puppies into other colors in order to eliminate the difference and make all the puppies have one common color.
Unfortunately, due to bureaucratic reasons and restricted budget, there's only one operation Slava can perform: he can choose a color x such that there are currently at least two puppies of color x and recolor all puppies of the color x into some arbitrary color y. Luckily, this operation can be applied multiple times (including zero).
For example, if the number of puppies is 7 and their colors are represented as the string "abababc", then in one operation Slava can get the results "zbzbzbc", "bbbbbbc", "aaaaaac", "acacacc" and others. However, if the current color sequence is "abababc", then he can't choose x='c' right now, because currently only one puppy has the color 'c'.
Help Slava and the committee determine whether it is possible to standardize all the puppies, i.e. after Slava's operations all the puppies should have the same color.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^5) — the number of puppies.
The second line contains a string s of length n consisting of lowercase Latin letters, where the i-th symbol denotes the i-th puppy's color.
Output
If it's possible to recolor all puppies into one color, print "Yes".
Otherwise print "No".
Output the answer without quotation signs.
Examples
Input
6
aabddc
Output
Yes
Input
3
abc
Output
No
Input
3
jjj
Output
Yes
Note
In the first example Slava can perform the following steps:
1. take all puppies of color 'a' (a total of two) and recolor them into 'b';
2. take all puppies of color 'd' (a total of two) and recolor them into 'c';
3. take all puppies of color 'b' (three puppies for now) and recolor them into 'c'.
In the second example it's impossible to recolor any of the puppies.
In the third example all the puppies' colors are the same; thus there's no need to recolor anything.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
class abio {
static const unsigned BUF_SZ = 65536;
FILE *istream, *ostream;
char ibuf[BUF_SZ], obuf[BUF_SZ];
bool reached_eof;
size_t ip, isz;
size_t op, osz;
inline void clear_ibuf(void) { ip = isz = 0u; }
inline void clear_obuf(void) { op = osz = 0u; }
inline void clear_buffer(void) {
reached_eof = false;
clear_ibuf();
clear_obuf();
}
inline size_t read_buffer(void) {
isz = fread(ibuf, sizeof(char), BUF_SZ, istream);
ip = 0;
return isz;
}
inline size_t write_buffer(void) {
if (osz) {
size_t ret = fwrite(obuf + op, sizeof(char), osz - op, ostream);
op += ret;
if (op == osz) clear_obuf();
return ret;
}
return 0;
}
inline abio &reach_eof(void) {
reached_eof = true;
return (*this);
}
public:
static const char endl = '\n';
abio(FILE *input = stdin, FILE *output = stdout) {
this->istream = input;
this->ostream = output;
clear_buffer();
}
abio(const char *input, const char *output) {
this->istream = fopen(input, "r");
this->istream = fopen(output, "w+");
clear_buffer();
}
~abio(void) {
write_buffer();
fclose(istream);
fclose(ostream);
}
operator bool() const { return (!reached_eof); }
inline int getchar(void) {
if (0 == isz || isz == ip) read_buffer();
if (0 == isz || isz == ip) return EOF;
return ibuf[ip++];
}
inline int putchar(int ch) {
if (osz == BUF_SZ) write_buffer();
if (osz == BUF_SZ) return EOF;
return (obuf[osz++] = ch);
}
abio &read_int(int &x) {
int flag = 0, ch = getchar();
if (EOF == ch) return (this->reach_eof());
x = 0;
while ((EOF != ch) && (('-' != ch) && ((ch < '0') || (ch > '9'))))
ch = getchar();
if (EOF == ch) return (this->reach_eof());
if ('-' == ch) {
flag = 1;
ch = getchar();
}
for (; (((ch >= '0') && (ch <= '9'))); ch = getchar()) {
x *= 10;
x += (ch - '0');
}
if (flag) x *= (-1);
return (*this);
}
abio &read_ll(long long int &x) {
int flag = 0, ch = getchar();
if (EOF == ch) return (this->reach_eof());
x = 0ll;
while ((EOF != ch) && (('-' != ch) && ((ch < '0') || (ch > '9'))))
ch = getchar();
if (EOF == ch) return (this->reach_eof());
if ('-' == ch) {
flag = 1;
ch = getchar();
}
for (; (((ch >= '0') && (ch <= '9'))); ch = getchar()) {
x *= (10ll);
x += (ch - '0');
}
if (flag) x *= (-1);
return (*this);
}
abio &read_s(char *s, const char interrupt = ' ') {
int ch = getchar();
while ((EOF != ch) && (ch < '!' || ch > '~')) ch = getchar();
if (EOF == ch) return (this->reach_eof());
for (; (EOF != ch) && (interrupt != ch) && (ch >= ' ' && ch <= '~');
ch = getchar())
(*s++) = ch;
(*s) = 0;
return (*this);
}
abio &write_int(int x, char append = 0) {
int d[20], nd = 0;
if (0 == x) putchar('0');
if (x < 0) {
putchar('-');
x = -x;
}
while (x) {
d[nd++] = x % 10;
x /= 10;
}
while (nd--) putchar('0' + d[nd]);
if (append) putchar(append);
return (*this);
}
abio &write_ll(long long int x, char append = 0) {
int d[20], nd = 0;
if (0 == x) putchar('0');
if (x < 0) {
putchar('-');
x = -x;
}
while (x) {
d[nd++] = x % 10;
x /= 10;
}
while (nd--) putchar('0' + d[nd]);
if (append) putchar(append);
return (*this);
}
abio &write_s(const char *s, char append = 0) {
while (*s) putchar(*s++);
if (append) putchar(append);
return (*this);
}
abio &operator>>(char &ch) {
ch = getchar();
if (EOF == ch) return (this->reach_eof());
return (*this);
}
abio &operator>>(int &x) { return read_int(x); }
abio &operator>>(long long int &x) { return read_ll(x); }
abio &operator>>(char *s) { return read_s(s); }
abio &operator<<(const char ch) {
putchar(ch);
return (*this);
}
abio &operator<<(const int x) { return write_int(x); }
abio &operator<<(const long long int x) { return write_ll(x); }
abio &operator<<(const char *s) { return write_s(s); }
} io;
int n, s[100005];
int main() {
io >> n;
if (n > 26 || n < 2) {
io << "Yes\n" << io.endl;
return 0;
}
while (n--) {
char c;
io >> c;
s[c - 'a']++;
if (s[c - 'a'] > 1) {
io << "Yes\n" << io.endl;
return 0;
}
}
io << "No\n" << io.endl;
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
You have integer n. Calculate how many ways are there to fully cover belt-like area of 4n-2 triangles with diamond shapes.
Diamond shape consists of two triangles. You can move, rotate or flip the shape, but you cannot scale it.
2 coverings are different if some 2 triangles are covered by the same diamond shape in one of them and by different diamond shapes in the other one.
Please look at pictures below for better understanding.
<image> On the left you can see the diamond shape you will use, and on the right you can see the area you want to fill.
<image> These are the figures of the area you want to fill for n = 1, 2, 3, 4.
You have to answer t independent test cases.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^{4}) — the number of test cases.
Each of the next t lines contains a single integer n (1 ≤ n ≤ 10^{9}).
Output
For each test case, print the number of ways to fully cover belt-like area of 4n-2 triangles using diamond shape. It can be shown that under given constraints this number of ways doesn't exceed 10^{18}.
Example
Input
2
2
1
Output
2
1
Note
In the first test case, there are the following 2 ways to fill the area:
<image>
In the second test case, there is a unique way to fill the area:
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int k;
scanf("%d", &k);
for (int i = 0; i < k; i++) {
int d;
scanf("%d", &d);
printf("%d\n", d);
}
return 0;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
There is an Amidakuji that consists of w vertical bars and has a height (the number of steps to which horizontal bars can be added) of h. w is an even number. Of the candidates for the place to add the horizontal bar of this Amidakuji, the ath from the top and the bth from the left are called (a, b). (When a horizontal bar is added to (a, b), the bth and b + 1th vertical bars from the left are connected in the ath row from the top.) Such places are h (w −1) in total. (1 ≤ a ≤ h, 1 ≤ b ≤ w − 1) Exists.
Sunuke added all horizontal bars to the places (a, b) where a ≡ b (mod 2) is satisfied. Next, Sunuke erased the horizontal bar at (a1, b1), ..., (an, bn). Find all the numbers from the left at the bottom when you select the i-th from the left at the top.
Constraints
* 1 ≤ h, w, n ≤ 200000
* w is even
* 1 ≤ ai ≤ h
* 1 ≤ bi ≤ w − 1
* ai ≡ bi (mod 2)
* There are no different i, j such that (ai, bi) = (aj, bj)
Input
h w n
a1 b1
.. ..
an bn
Output
Output w lines. On the i-th line, output the number from the left at the bottom when the i-th from the left is selected at the top.
Examples
Input
4 4 1
3 3
Output
2
3
4
1
Input
10 6 10
10 4
4 4
5 1
4 2
7 3
1 3
2 4
8 2
7 5
7 1
Output
1
4
3
2
5
6
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct data {
int a, b;
bool operator<(const data &r) const { return a < r.a; }
};
int h, w, n;
vector<data> v;
vector<int> res, pre;
void solve();
int calc(int x, int y);
int main() {
cin >> h >> w >> n;
v.resize(n);
res.resize(w);
pre.resize(w);
for(int i = 0; i < w; ++i) pre[i] = i;
for(int i = 0; i < n; ++i) cin >> v[i].a >> v[i].b;
sort(v.begin(), v.end());
solve();
for(int i = 0; i < w; ++i) cout << res[i] + 1 << endl;
return 0;
}
void solve() {
for(int i = 0; i < n; ++i)
swap(pre[calc(v[i].a - 1, v[i].b - 1)],
pre[calc(v[i].a - 1, v[i].b)]);
for(int i = 0; i < w; ++i) res[pre[calc(h, i)]] = i;
}
int calc(int x, int y) {
x %= 2 * w;
if((y ^ x) % 2 == 0) {
int tmp = min(x, y);
x -= tmp;
y -= tmp;
if(x > 0) --x;
tmp = min(x, w - 1);
y += tmp;
x -= tmp;
if(x > 0) --x;
y -= min(x, w - 1);
}
else {
int tmp = min(x, w - 1 - y);
x -= tmp;
y += tmp;
if(x > 0) --x;
tmp = min(x, w - 1);
y -= tmp;
x -= tmp;
if(x > 0) --x;
y += min(x, w - 1);
}
return y;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
Anton is playing a very interesting computer game, but now he is stuck at one of the levels. To pass to the next level he has to prepare n potions.
Anton has a special kettle, that can prepare one potions in x seconds. Also, he knows spells of two types that can faster the process of preparing potions.
1. Spells of this type speed up the preparation time of one potion. There are m spells of this type, the i-th of them costs bi manapoints and changes the preparation time of each potion to ai instead of x.
2. Spells of this type immediately prepare some number of potions. There are k such spells, the i-th of them costs di manapoints and instantly create ci potions.
Anton can use no more than one spell of the first type and no more than one spell of the second type, and the total number of manapoints spent should not exceed s. Consider that all spells are used instantly and right before Anton starts to prepare potions.
Anton wants to get to the next level as fast as possible, so he is interested in the minimum number of time he needs to spent in order to prepare at least n potions.
Input
The first line of the input contains three integers n, m, k (1 ≤ n ≤ 2·109, 1 ≤ m, k ≤ 2·105) — the number of potions, Anton has to make, the number of spells of the first type and the number of spells of the second type.
The second line of the input contains two integers x and s (2 ≤ x ≤ 2·109, 1 ≤ s ≤ 2·109) — the initial number of seconds required to prepare one potion and the number of manapoints Anton can use.
The third line contains m integers ai (1 ≤ ai < x) — the number of seconds it will take to prepare one potion if the i-th spell of the first type is used.
The fourth line contains m integers bi (1 ≤ bi ≤ 2·109) — the number of manapoints to use the i-th spell of the first type.
There are k integers ci (1 ≤ ci ≤ n) in the fifth line — the number of potions that will be immediately created if the i-th spell of the second type is used. It's guaranteed that ci are not decreasing, i.e. ci ≤ cj if i < j.
The sixth line contains k integers di (1 ≤ di ≤ 2·109) — the number of manapoints required to use the i-th spell of the second type. It's guaranteed that di are not decreasing, i.e. di ≤ dj if i < j.
Output
Print one integer — the minimum time one has to spent in order to prepare n potions.
Examples
Input
20 3 2
10 99
2 4 3
20 10 40
4 15
10 80
Output
20
Input
20 3 2
10 99
2 4 3
200 100 400
4 15
100 800
Output
200
Note
In the first sample, the optimum answer is to use the second spell of the first type that costs 10 manapoints. Thus, the preparation time of each potion changes to 4 seconds. Also, Anton should use the second spell of the second type to instantly prepare 15 potions spending 80 manapoints. The total number of manapoints used is 10 + 80 = 90, and the preparation time is 4·5 = 20 seconds (15 potions were prepared instantly, and the remaining 5 will take 4 seconds each).
In the second sample, Anton can't use any of the spells, so he just prepares 20 potions, spending 10 seconds on each of them and the answer is 20·10 = 200.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int sz = 2e6 + 10;
const int mod = 1e9 + 7;
unsigned long long int ar[sz], br[sz], cr[sz], dr[sz];
void solve() {
unsigned long long int n, m, k, x, s, i, j, mn, have;
cin >> n >> m >> k >> x >> s;
mn = 1LL * n * x;
for (i = 1; i <= m; i++) cin >> ar[i];
for (i = 1; i <= m; i++) {
cin >> br[i];
if (br[i] <= s) mn = min(mn, ar[i] * n);
}
for (i = 1; i <= k; i++) cin >> cr[i];
for (i = 1; i <= k; i++) {
cin >> dr[i];
if (dr[i] <= s && cr[i] >= n) mn = 0;
}
ar[0] = x;
for (i = 0; i <= m; i++) {
if (br[i] <= s) {
have = s - br[i];
auto it = upper_bound(dr, dr + k + 1, have) - dr;
it--;
mn = min(mn, 1LL * (n - cr[it]) * ar[i]);
}
}
cout << mn << endl;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t = 1;
while (t--) {
solve();
}
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
AtCoDeer the deer has N square tiles. The tiles are numbered 1 through N, and the number given to each tile is written on one side of the tile. Also, each corner of each tile is painted in one of the 1000 colors, which are represented by the integers 0 between 999. The top-left, top-right, bottom-right and bottom-left corner of the tile with the number i are painted in color C_{i,0}, C_{i,1}, C_{i,2} and C_{i,3}, respectively, when seen in the direction of the number written on the tile (See Figure 1).
<image>
Figure 1: The correspondence between the colors of a tile and the input
AtCoDeer is constructing a cube using six of these tiles, under the following conditions:
* For each tile, the side with the number must face outward.
* For each vertex of the cube, the three corners of the tiles that forms it must all be painted in the same color.
Help him by finding the number of the different cubes that can be constructed under the conditions. Since each tile has a number written on it, two cubes are considered different if the set of the used tiles are different, or the tiles are used in different directions, even if the formation of the colors are the same. (Each tile can be used in one of the four directions, obtained by 90° rotations.) Two cubes are considered the same only if rotating one in the three dimensional space can obtain an exact copy of the other, including the directions of the tiles.
<image>
Figure 2: The four directions of a tile
Constraints
* 6≦N≦400
* 0≦C_{i,j}≦999 (1≦i≦N , 0≦j≦3)
Input
The input is given from Standard Input in the following format:
N
C_{1,0} C_{1,1} C_{1,2} C_{1,3}
C_{2,0} C_{2,1} C_{2,2} C_{2,3}
:
C_{N,0} C_{N,1} C_{N,2} C_{N,3}
Output
Print the number of the different cubes that can be constructed under the conditions.
Examples
Input
6
0 1 2 3
0 4 6 1
1 6 7 2
2 7 5 3
6 4 5 7
4 0 3 5
Output
1
Input
8
0 0 0 0
0 0 1 1
0 1 0 1
0 1 1 0
1 0 0 1
1 0 1 0
1 1 0 0
1 1 1 1
Output
144
Input
6
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
Output
122880
### Response
```cpp
#include<cstdio>
int N,C[410][4],cnt;
long long id(int*a){
long long v=-1;
for(int d=0;d<4;d++){
long long t=0;
for(int i=0;i<4;i++)t|=1ll*a[d+i&3]<<i*10;
t>v?v=t,cnt=1:t==v?++cnt:0;
}
return v;
}
const int mod=10007;
struct item{long long x;int cnt;item*next;}items[1610],*nit=items,*fir[mod];
void ins(long long x){
int h=x%mod;
for(item*it=fir[h];it;it=it->next)
if(it->x==x){++it->cnt;return;}
*nit=(item){x,1,fir[h]};
fir[h]=nit++;
}
int fd(long long x,bool*suc){
for(item*it=fir[x%mod];it;it=it->next)
if(it->x==x)return*suc=1,it->cnt--;
return*suc=0;
}
int main(){
scanf("%d",&N);
for(int i=0;i<N;i++){
for(int j=0;j<4;j++)scanf("%d",C[i]+j);
ins(id(C[i]));
}
long long sum=0;
bool tmp;
for(int x=0;x<N;x++){
fd(id(C[x]),&tmp);
for(int y=x+1;y<N;y++){
fd(id(C[y]),&tmp);
for(int d=0;d<4;d++){
long long t=1,z[4];
bool suc[4]={0};
for(int i=0;i<4&&t;i++){
int a[4]={C[y][d-i&3],C[y][d-i-1&3],C[x][i+1&3],C[x][i&3]};
z[i]=id(a);
t*=fd(z[i],suc+i)*cnt;
}
for(int i=0;i<4;i++)if(suc[i])ins(z[i]);
sum+=t;
}
ins(id(C[y]));
}
ins(id(C[x]));
}
printf("%lld\n",sum/3);
}
``` |
### Prompt
Generate a cpp solution to the following problem:
Write a program which reads an integer $S$ [second] and converts it to $h:m:s$ where $h$, $m$, $s$ denote hours, minutes (less than 60) and seconds (less than 60) respectively.
Constraints
* $0 \leq S \leq 86400$
Input
An integer $S$ is given in a line.
Output
Print $h$, $m$ and $s$ separated by ':'. You do not need to put '0' for a value, which consists of a digit.
Example
Input
46979
Output
13:2:59
### Response
```cpp
#include <stdio.h>
int main(){
int t,h,m,s;
scanf("%d",&t);
h=t/3600;
m=t/60-h*60;
s=t%60;
printf("%d:%d:%d\n",h,m,s);
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
Find the largest integer that can be formed with exactly N matchsticks, under the following conditions:
* Every digit in the integer must be one of the digits A_1, A_2, ..., A_M (1 \leq A_i \leq 9).
* The number of matchsticks used to form digits 1, 2, 3, 4, 5, 6, 7, 8, 9 should be 2, 5, 5, 4, 5, 6, 3, 7, 6, respectively.
Constraints
* All values in input are integers.
* 2 \leq N \leq 10^4
* 1 \leq M \leq 9
* 1 \leq A_i \leq 9
* A_i are all different.
* There exists an integer that can be formed by exactly N matchsticks under the conditions.
Input
Input is given from Standard Input in the following format:
N M
A_1 A_2 ... A_M
Output
Print the largest integer that can be formed with exactly N matchsticks under the conditions in the problem statement.
Examples
Input
20 4
3 7 8 4
Output
777773
Input
101 9
9 8 7 6 5 4 3 2 1
Output
71111111111111111111111111111111111111111111111111
Input
15 3
5 4 6
Output
654
### Response
```cpp
#include <iostream>
#include <algorithm>
using namespace std;
int n, m;
int a[9];
int b[9] = { 2, 5, 5, 4, 5, 6, 3, 7, 6 };
int dp[10001];
int main()
{
cin >> n >> m;
dp[0] = 0;
for (int i = 1; i < 10001; i++)
dp[i] = -10000;
for (int i = 0; i < m; i++)
cin >> a[i];
sort(a, a + m, greater<int>());
for (int i = 0; i < m; i++) {
for (int j = 1; j < n + 1; j++) {
if (j - b[a[i] - 1] >= 0 && dp[j - b[a[i] - 1]] != -10000)
dp[j] = max(dp[j], dp[j - b[a[i] - 1]] + 1);
}
}
int k = n;
while (k > 0) {
for (int i = 0; i < m; i++) {
if (k - b[a[i] - 1] >= 0 && dp[k] - dp[k - b[a[i] - 1]] == 1) {
k -= b[a[i] - 1];
cout << a[i];
break;
}
}
}
cout << endl;
return 0;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
When l is an odd number, the median of l numbers a_1, a_2, ..., a_l is the (\frac{l+1}{2})-th largest value among a_1, a_2, ..., a_l.
You are given N numbers X_1, X_2, ..., X_N, where N is an even number. For each i = 1, 2, ..., N, let the median of X_1, X_2, ..., X_N excluding X_i, that is, the median of X_1, X_2, ..., X_{i-1}, X_{i+1}, ..., X_N be B_i.
Find B_i for each i = 1, 2, ..., N.
Constraints
* 2 \leq N \leq 200000
* N is even.
* 1 \leq X_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
X_1 X_2 ... X_N
Output
Print N lines. The i-th line should contain B_i.
Examples
Input
4
2 4 4 3
Output
4
3
3
4
Input
2
1 2
Output
2
1
Input
6
5 5 4 4 3 3
Output
4
4
4
4
4
4
### Response
```cpp
#include <iostream>
#include <algorithm>
using namespace std;
int a[1000006], b[1000006];
int main(){
int n;
cin >> n;
for (int i = 1; i <= n; ++ i){
cin >> a[i];
b[i] = a[i];
}
sort(a + 1, a + 1 + n);
int mid1 = a[n / 2], mid2 = a[n / 2 + 1];
for (int i = 1; i <= n; ++ i)
if (b[i] <= mid1)
cout << mid2 << endl;
else
cout << mid1 << endl;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
There are less than 60 years left till the 900-th birthday anniversary of a famous Italian mathematician Leonardo Fibonacci. Of course, such important anniversary needs much preparations.
Dima is sure that it'll be great to learn to solve the following problem by the Big Day: You're given a set A, consisting of numbers l, l + 1, l + 2, ..., r; let's consider all its k-element subsets; for each such subset let's find the largest common divisor of Fibonacci numbers with indexes, determined by the subset elements. Among all found common divisors, Dima is interested in the largest one.
Dima asked to remind you that Fibonacci numbers are elements of a numeric sequence, where F1 = 1, F2 = 1, Fn = Fn - 1 + Fn - 2 for n ≥ 3.
Dima has more than half a century ahead to solve the given task, but you only have two hours. Count the residue from dividing the sought largest common divisor by m.
Input
The first line contains four space-separated integers m, l, r and k (1 ≤ m ≤ 109; 1 ≤ l < r ≤ 1012; 2 ≤ k ≤ r - l + 1).
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use cin, cout streams or the %I64d specifier.
Output
Print a single integer — the residue from dividing the sought greatest common divisor by m.
Examples
Input
10 1 8 2
Output
3
Input
10 1 8 3
Output
1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int64_t MAXN = 1e5 + 5;
const int64_t MAXINT = 1e9;
const int64_t MAXLL = 1e18;
int64_t MOD = 1e9 + 7;
struct Matrix {
int64_t n, m;
vector<vector<int64_t> > matrix;
Matrix(int64_t n_, int64_t m_) {
n = n_;
m = m_;
matrix.resize(n);
for (int64_t i = 0; i < n; ++i) matrix[i].resize(m);
}
void ones() {
if (n != m) return;
for (int64_t i = 0; i < n; ++i) matrix[i][i] = 1;
}
};
Matrix operator*(const Matrix &m1, const Matrix &m2) {
Matrix result(m1.n, m2.m);
for (int64_t i = 0; i < result.n; ++i) {
for (int64_t j = 0; j < result.m; ++j) {
for (int64_t p = 0; p < m1.m; ++p) {
int64_t prod = (m1.matrix[i][p] * m2.matrix[p][j]) % MOD;
result.matrix[i][j] = (result.matrix[i][j] + prod) % MOD;
}
}
}
return result;
}
Matrix binpow(Matrix a, int64_t p) {
Matrix res(a.n, a.m);
res.ones();
while (p) {
if (p % 2 == 1) {
res = res * a;
}
a = a * a;
p /= 2;
}
return res;
}
int64_t nthfib(int64_t n) {
Matrix b(2, 2);
b.matrix[0][0] = 0;
b.matrix[0][1] = 1;
b.matrix[1][0] = 1;
b.matrix[1][1] = 1;
Matrix fib(1, 2);
fib.matrix[0][0] = 0;
fib.matrix[0][1] = 1;
auto result = fib * binpow(b, n);
return result.matrix[0][0];
}
int64_t f(int64_t l, int64_t r, int64_t ans) {
int64_t a = r / ans;
int64_t b = l / ans + (l % ans > 0);
return a - b + 1;
}
void solve() {
int64_t l, r, k;
cin >> MOD >> l >> r >> k;
vector<int64_t> good;
for (int64_t i = 1; i * i <= r; i++) {
good.push_back(i);
good.push_back(r / i);
}
for (int64_t i = 1; i * i <= l; i++) {
if (l % i == 0)
good.push_back(l / i);
else {
if (i > 1) good.push_back(l / (i - 1));
}
}
int64_t best = 1;
for (int64_t ans : good) {
if (f(l, r, ans) >= k) best = max((int64_t)best, (int64_t)ans);
}
cout << nthfib(best) << '\n';
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
solve();
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
You are given a string s consisting of n lowercase Latin letters.
Let's define a substring as a contiguous subsegment of a string. For example, "acab" is a substring of "abacaba" (it starts in position 3 and ends in position 6), but "aa" or "d" aren't substrings of this string. So the substring of the string s from position l to position r is s[l; r] = s_l s_{l + 1} ... s_r.
You have to choose exactly one of the substrings of the given string and reverse it (i. e. make s[l; r] = s_r s_{r - 1} ... s_l) to obtain a string that is less lexicographically. Note that it is not necessary to obtain the minimum possible string.
If it is impossible to reverse some substring of the given string to obtain a string that is less, print "NO". Otherwise print "YES" and any suitable substring.
String x is lexicographically less than string y, if either x is a prefix of y (and x ≠ y), or there exists such i (1 ≤ i ≤ min(|x|, |y|)), that x_i < y_i, and for any j (1 ≤ j < i) x_j = y_j. Here |a| denotes the length of the string a. The lexicographic comparison of strings is implemented by operator < in modern programming languages.
Input
The first line of the input contains one integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the length of s.
The second line of the input contains the string s of length n consisting only of lowercase Latin letters.
Output
If it is impossible to reverse some substring of the given string to obtain a string which is lexicographically less, print "NO". Otherwise print "YES" and two indices l and r (1 ≤ l < r ≤ n) denoting the substring you have to reverse. If there are multiple answers, you can print any.
Examples
Input
7
abacaba
Output
YES
2 5
Input
6
aabcfg
Output
NO
Note
In the first testcase the resulting string is "aacabba".
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, f = 0, p;
cin >> n;
string s;
cin >> s;
for (i = 1; i < n; i++) {
if (s[i] < s[i - 1]) {
f = 1;
p = i - 1;
break;
}
}
if (f == 1)
cout << "YES\n" << p + 1 << " " << p + 2 << "\n";
else
cout << "NO\n";
}
``` |
### Prompt
Generate a CPP solution to the following problem:
Yuta is addicted to the popular game "Beat Panel" at a nearby arcade. The game consists of a total of 16 panel-type buttons, 4x4, arranged in a grid as shown.
<image>
As shown in the figure, the buttons are arranged in the order of button 1, button 2,…, button 16 from the upper left to the lower right. In the game, you will hear a beat sound at regular intervals and a final sound at the end. Multiple buttons light up at the same time as the beat sounds. In some cases, even one does not shine. The player can press multiple buttons at the same time using the fingers of both hands from immediately after the beat sound to the next sound. It is also possible not to press anything. The game ends as soon as the end sound is heard.
Yuta has mastered c ways of pressing, and each time a beat sounds, he decides one of those pressing methods and presses the button. If the buttons you press are lit, those buttons will be lit and the number of buttons that have disappeared will be added to the player's score. Also, once a button is lit, the light will not go out until the button is pressed.
A program that outputs the maximum score that Yuta can obtain by inputting how to illuminate the button when the beat sound is played n times and how to press the button in c ways that Yuta has learned. Please create.
input
The input consists of multiple datasets. The end of the input is indicated by two lines of zeros. Each dataset is given in the following format.
n c
a1,1 a1,2 ... a1,16
a2,1 a2,2 ... a2,16
...
an, 1 an, 2 ... an, 16
b1,1 b1,2 ... b1,16
b2,1 b2,2 ... b2,16
...
bc,1 bc,2 ... bc,16
The first line consists of two integers separated by one space. n (1 ≤ n ≤ 30) indicates the number of beat sounds, and c (1 ≤ c ≤ 30) indicates the number of button presses that you have learned. The following n + c lines give how to illuminate the button and how to press the button. The input item in the line is separated by one blank. ak and i indicate how the button i shines when the kth beat sound is heard, and bj and i indicate whether the button i is pressed by pressing the jth button in the middle of c. As for the values of ak and i, 0 means "does not shine" and 1 means "shines". For the values of bj and i, 0 means "do not press" and 1 means "press".
The number of datasets does not exceed 20.
output
For each data set, the maximum score is output on one line.
Example
Input
2 2
0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1
1 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0
0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1
1 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0
2 2
0 0 1 0 1 1 1 1 0 0 1 0 0 0 1 0
0 1 0 1 0 1 1 1 0 1 0 1 0 0 0 0
0 0 1 0 1 0 0 0 0 0 1 0 0 0 1 0
0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0
5 3
0 0 0 0 0 1 1 0 0 1 1 0 0 0 0 0
1 0 0 1 0 1 1 0 0 1 1 0 1 0 0 1
0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0
0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0
0 1 1 0 0 0 0 0 0 0 0 0 0 1 1 0
0 0 0 0 0 1 1 0 0 1 1 0 0 0 0 0
1 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0
0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1
0 0
Output
8
7
16
### Response
```cpp
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <climits>
#include <cfloat>
#include <ctime>
#include <cassert>
#include <map>
#include <utility>
#include <set>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <sstream>
#include <complex>
#include <stack>
#include <queue>
#include <numeric>
#include <list>
#include <iomanip>
#include <fstream>
#include <bitset>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define foreach(it, c) for (__typeof__((c).begin()) it=(c).begin(); it != (c).end(); ++it)
#define rforeach(it, c) for (__typeof__((c).rbegin()) it=(c).rbegin(); it != (c).rend(); ++it)
#define all(c) (c).begin(), (c).end()
#define rall(c) (c).rbegin(), (c).rend()
#define CL(arr, val) memset(arr, val, sizeof(arr))
#define COPY(dest, src) memcpy(dest, src, sizeof(dest))
#define ten(n) ((long long)(1e##n))
#define bin(n) (1LL << (n))
#define erep(i, n) for (int i = 0; i <= (int)(n); ++i)
#define revrep(i, n) for (int i = (n); i >= 0; --i)
#define pb push_back
template <class T> void chmax(T& a, const T& b) { a = max(a, b); }
template <class T> void chmin(T& a, const T& b) { a = min(a, b); }
template <class T> T round_up(T a, T b) { return (a + b - 1) / b; }
template <class T> void uniq(vector<T>& c) { sort(c.begin(), c.end()); c.erase(unique(c.begin(), c.end()), c.end()); }
template <class T> string to_s(const T& a) { ostringstream os; os << a; return os.str(); }
template <class T> T to_T(const string& s) { istringstream is(s); T res; is >> res; return res; }
template <class T, class U> ostream& operator<<(ostream& os, pair<T, U>& p) { os << "( " << p.first << ", " << p.second << " )"; return os; }
template <class T> void print(T a, int n, const string& deli = " ", int br = 1) { for (int i = 0; i < n; ++i) { cout << a[i]; if (i + 1 != n) cout << deli; } while (br--) cout << endl; }
template <class T> void print(const T& c, const string& deli = " ", int br = 1) { foreach (it, c) { cout << *it; if (++it != c.end()) cout << deli;--it; } while (br--) cout << endl; }
template <class T> void print2d(T a, int w, int h, int width = -1, int br = 1) { for (int i = 0; i < h; ++i) { for (int j = 0; j < w; ++j) { if (width != -1) cout.width(width); cout << a[i][j] << ' '; } cout << endl; } while (br--) cout << endl; }
template <class T> void input(T& a, int n) { for (int i = 0; i < n; ++i) cin >> a[i]; }
template <class T> void input(T* a, int n) { for (int i = 0; i < n; ++i) cin >> a[i]; }
void fix_pre(int n) { cout.setf(ios::fixed, ios::floatfield); cout.precision(10); }
void fast_io() { cin.tie(0); ios::sync_with_stdio(false); }
#define trace(x) (cout << #x << ": " << (x) << endl)
bool in_rect(int x, int y, int w, int h) { return 0 <= x && x < w && 0 <= y && y < h; }
typedef long long ll;
typedef pair<int, int> pint;
// y(v): v>^< y(^): ^>v<
const int dx[] = { 0, 1, 0, -1 };
const int dy[] = { 1, 0, -1, 0 };
const double PI = acos(-1.0);
#define F first
#define S second
vector<int> inp(int n)
{
vector<int> res(n);
rep(i, n)
{
int a[16];
input(a, 16);
rep(j, 16)
res[i] |= a[j] * bin(j);
}
return res;
}
int main()
{
int n, c;
while (cin >> n >> c, n)
{
vector<int> a = inp(n);
vector<int> b = inp(c);
const int inf = ten(6);
static int dp[33][1 << 16];
static int score[33][1 << 16];
rep(i, c) rep(s, bin(16))
score[i][s] = __builtin_popcount(b[i] & s);
erep(i, n) rep(s, bin(16))
dp[i][s] = -inf;
dp[0][0] = 0;
rep(i, n) rep(s, bin(16))
{
if (dp[i][s] >= 0)
{
int f = s | a[i];
rep(j, c)
chmax(dp[i + 1][f & ~b[j]], dp[i][s] + score[j][f]);
}
}
cout << *max_element(dp[n], dp[n] + bin(16)) << endl;
}
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
Iahub is a big fan of tourists. He wants to become a tourist himself, so he planned a trip. There are n destinations on a straight road that Iahub wants to visit. Iahub starts the excursion from kilometer 0. The n destinations are described by a non-negative integers sequence a1, a2, ..., an. The number ak represents that the kth destination is at distance ak kilometers from the starting point. No two destinations are located in the same place.
Iahub wants to visit each destination only once. Note that, crossing through a destination is not considered visiting, unless Iahub explicitly wants to visit it at that point. Also, after Iahub visits his last destination, he doesn't come back to kilometer 0, as he stops his trip at the last destination.
The distance between destination located at kilometer x and next destination, located at kilometer y, is |x - y| kilometers. We call a "route" an order of visiting the destinations. Iahub can visit destinations in any order he wants, as long as he visits all n destinations and he doesn't visit a destination more than once.
Iahub starts writing out on a paper all possible routes and for each of them, he notes the total distance he would walk. He's interested in the average number of kilometers he would walk by choosing a route. As he got bored of writing out all the routes, he asks you to help him.
Input
The first line contains integer n (2 ≤ n ≤ 105). Next line contains n distinct integers a1, a2, ..., an (1 ≤ ai ≤ 107).
Output
Output two integers — the numerator and denominator of a fraction which is equal to the wanted average number. The fraction must be irreducible.
Examples
Input
3
2 3 5
Output
22 3
Note
Consider 6 possible routes:
* [2, 3, 5]: total distance traveled: |2 – 0| + |3 – 2| + |5 – 3| = 5;
* [2, 5, 3]: |2 – 0| + |5 – 2| + |3 – 5| = 7;
* [3, 2, 5]: |3 – 0| + |2 – 3| + |5 – 2| = 7;
* [3, 5, 2]: |3 – 0| + |5 – 3| + |2 – 5| = 8;
* [5, 2, 3]: |5 – 0| + |2 – 5| + |3 – 2| = 9;
* [5, 3, 2]: |5 – 0| + |3 – 5| + |2 – 3| = 8.
The average travel distance is <image> = <image> = <image>.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long GCD(long long a, long long b) { return b ? GCD(b, a % b) : a; }
long long factorial(long long n) {
if (n < 0) return 0LL;
if (n < 2) return 1LL;
}
int main() {
int n;
scanf("%d", &n);
vector<int> des;
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
des.push_back(x);
}
long long sum = 0;
sort(des.begin(), des.end());
for (int i = 0; i <= n - 1; i++) {
int pos = i, neg = n - 1 - i;
sum += 2LL * des[i] * (pos - neg) + des[i];
}
long long g = GCD(sum, n);
sum /= g;
n /= g;
cout << sum << " " << n << endl;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
A boy named Gena really wants to get to the "Russian Code Cup" finals, or at least get a t-shirt. But the offered problems are too complex, so he made an arrangement with his n friends that they will solve the problems for him.
The participants are offered m problems on the contest. For each friend, Gena knows what problems he can solve. But Gena's friends won't agree to help Gena for nothing: the i-th friend asks Gena xi rubles for his help in solving all the problems he can. Also, the friend agreed to write a code for Gena only if Gena's computer is connected to at least ki monitors, each monitor costs b rubles.
Gena is careful with money, so he wants to spend as little money as possible to solve all the problems. Help Gena, tell him how to spend the smallest possible amount of money. Initially, there's no monitors connected to Gena's computer.
Input
The first line contains three integers n, m and b (1 ≤ n ≤ 100; 1 ≤ m ≤ 20; 1 ≤ b ≤ 109) — the number of Gena's friends, the number of problems and the cost of a single monitor.
The following 2n lines describe the friends. Lines number 2i and (2i + 1) contain the information about the i-th friend. The 2i-th line contains three integers xi, ki and mi (1 ≤ xi ≤ 109; 1 ≤ ki ≤ 109; 1 ≤ mi ≤ m) — the desired amount of money, monitors and the number of problems the friend can solve. The (2i + 1)-th line contains mi distinct positive integers — the numbers of problems that the i-th friend can solve. The problems are numbered from 1 to m.
Output
Print the minimum amount of money Gena needs to spend to solve all the problems. Or print -1, if this cannot be achieved.
Examples
Input
2 2 1
100 1 1
2
100 2 1
1
Output
202
Input
3 2 5
100 1 1
1
100 1 1
2
200 1 2
1 2
Output
205
Input
1 2 1
1 1 1
1
Output
-1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m, b;
vector<pair<int, pair<int, int> > > vec;
int x, k, mx;
long long ans[105];
long long dp[1 << 20][2];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> b;
for (int i = 0; i < n; i++) {
cin >> x >> k >> mx;
int mask = 0;
for (int j = 0, a; j < mx; j++) {
cin >> a;
a--;
mask |= (1 << a);
}
vec.push_back(make_pair(k, make_pair(x, mask)));
}
sort(vec.rbegin(), vec.rend());
dp[(1 << m) - 1][n & 1] = 0;
for (int i = 0; i < (1 << m) - 1; i++) dp[i][n & 1] = 2e18;
for (int i = n - 1; i >= 0; i--) {
long long c = vec[i].second.first;
int mask = vec[i].second.second;
for (int j = 0; j <= (1 << m) - 1; j++) {
long long &ret = dp[j][i & 1];
ret = dp[j][!(i & 1)];
ret = min(ret, dp[j | mask][!(i & 1)] + c);
}
ans[i] = dp[0][i & 1];
}
long long res = 3e18;
for (int i = 0; i < n; i++) {
long long x = vec[i].first;
res = min(res, ans[i] + x * 1ll * b);
}
if (res >= 2e18) res = -1;
cout << res << endl;
return 0;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
It's another Start[c]up finals, and that means there is pizza to order for the onsite contestants. There are only 2 types of pizza (obviously not, but let's just pretend for the sake of the problem), and all pizzas contain exactly S slices.
It is known that the i-th contestant will eat si slices of pizza, and gain ai happiness for each slice of type 1 pizza they eat, and bi happiness for each slice of type 2 pizza they eat. We can order any number of type 1 and type 2 pizzas, but we want to buy the minimum possible number of pizzas for all of the contestants to be able to eat their required number of slices. Given that restriction, what is the maximum possible total happiness that can be achieved?
Input
The first line of input will contain integers N and S (1 ≤ N ≤ 105, 1 ≤ S ≤ 105), the number of contestants and the number of slices per pizza, respectively. N lines follow.
The i-th such line contains integers si, ai, and bi (1 ≤ si ≤ 105, 1 ≤ ai ≤ 105, 1 ≤ bi ≤ 105), the number of slices the i-th contestant will eat, the happiness they will gain from each type 1 slice they eat, and the happiness they will gain from each type 2 slice they eat, respectively.
Output
Print the maximum total happiness that can be achieved.
Examples
Input
3 12
3 5 7
4 6 7
5 9 5
Output
84
Input
6 10
7 4 7
5 8 8
12 5 8
6 11 6
3 3 7
5 9 6
Output
314
Note
In the first example, you only need to buy one pizza. If you buy a type 1 pizza, the total happiness will be 3·5 + 4·6 + 5·9 = 84, and if you buy a type 2 pizza, the total happiness will be 3·7 + 4·7 + 5·5 = 74.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T prod(const T &a, const T &b, const T &mod) {
return ((a % mod) * (b % mod)) % mod;
}
template <typename T>
T pow_(const T &a, const T &b) {
if (!b) return 1;
T p = pow_(a, b / 2);
p *= p;
return (b % 2) ? (p * a) : p;
}
template <typename T>
T modpow(const T &a, const T &b, const T &mod) {
if (!b) return 1;
T p = modpow(a, b / 2);
p = prod(p, p);
return (b % 2) ? (prod(p, a)) : p;
}
template <typename T>
T max(const T &a, const T &b, const T &c) {
return max(a, max(b, c));
}
template <typename T>
T min(const T &a, const T &b, const T &c) {
return min(a, min(b, c));
}
template <typename T>
void dbg(const vector<T> &a, int l, int r) {
for (long long int i = l; i <= r; i++) cout << a[i] << " ";
cout << endl;
}
template <typename T>
void dbg(const vector<T> &a) {
for (long long int i = 0; i <= a.size() - 1; i++) cout << a[i] << " ";
cout << endl;
}
long long int n, s, num;
long long int f(long long int numa,
vector<pair<pair<long long int, long long int>,
pair<long long int, long long int> > >
a) {
if (numa < 0 || numa > num) return 0;
long long int numb = num - numa;
numa *= s;
numb *= s;
long long int i = 0, ret = 0;
while (i < a.size() && a[i].first.first <= 0) {
if (a[i].first.second > numa) {
a[i].first.second -= numa;
ret += numa * a[i].second.first;
numa = 0;
break;
}
ret += a[i].first.second * a[i].second.first;
numa -= a[i].first.second;
a[i].first.second = 0;
i++;
}
i = a.size() - 1;
while (i >= 0) {
if (a[i].first.second > numb) {
a[i].first.second -= numb;
ret += numb * a[i].second.second;
numb = 0;
break;
}
ret += a[i].first.second * a[i].second.second;
numb -= a[i].first.second;
a[i].first.second = 0;
i--;
}
i = 0;
while (numa > 0 && i < a.size()) {
long long int nm = min(numa, a[i].first.second);
ret += nm * a[i].second.first;
numa -= nm;
a[i].second.first -= nm;
i++;
}
i = 0;
while (numb > 0 && i < a.size()) {
long long int nm = min(numb, a[i].first.second);
ret += nm * a[i].second.second;
numb -= nm;
a[i].second.first -= nm;
i++;
}
return ret;
}
void main_() {
scanf("%lld%lld", &n, &s);
vector<pair<pair<long long int, long long int>,
pair<long long int, long long int> > >
vec;
long long int tot = 0;
for (long long int i = 0; i <= n - 1; i++) {
long long int c, a, b;
scanf("%lld%lld%lld", &c, &a, &b);
vec.push_back(make_pair(make_pair(b - a, c), make_pair(a, b)));
tot += c;
}
num = (tot + s - 1) / s;
sort(vec.begin(), vec.end());
long long int l = -1, r = num;
while ((r - l) > 1) {
long long int mid = (l + r) >> 1;
if (f(mid, vec) > f(mid + 1, vec))
r = mid;
else
l = mid;
}
cout << max(max(f(l - 1, vec), f(l, vec), f(l + 1, vec)), f(l + 2, vec))
<< endl;
}
int main() {
{ main_(); }
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
You are given two rectangles on a plane. The centers of both rectangles are located in the origin of coordinates (meaning the center of the rectangle's symmetry). The first rectangle's sides are parallel to the coordinate axes: the length of the side that is parallel to the Ox axis, equals w, the length of the side that is parallel to the Oy axis, equals h. The second rectangle can be obtained by rotating the first rectangle relative to the origin of coordinates by angle α.
<image>
Your task is to find the area of the region which belongs to both given rectangles. This region is shaded in the picture.
Input
The first line contains three integers w, h, α (1 ≤ w, h ≤ 106; 0 ≤ α ≤ 180). Angle α is given in degrees.
Output
In a single line print a real number — the area of the region which belongs to both given rectangles.
The answer will be considered correct if its relative or absolute error doesn't exceed 10 - 6.
Examples
Input
1 1 45
Output
0.828427125
Input
6 4 30
Output
19.668384925
Note
The second sample has been drawn on the picture above.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct Point {
double x, y;
Point(double a, double b) { x = a, y = b; }
Point() {}
};
Point operator+(Point A, Point B) { return Point(A.x + B.x, A.y + B.y); }
Point operator-(Point A, Point B) { return Point(A.x - B.x, A.y - B.y); }
Point operator*(double k, Point A) { return Point(A.x * k, A.y * k); }
bool operator<(Point A, Point B) {
if (fabs(A.x - B.x) < 1e-8) return A.y < B.y;
return A.x < B.x;
}
double cross(Point A, Point B) { return A.x * B.y - A.y * B.x; }
double area(Point A, Point B, Point C) { return cross(B - A, C - A); }
Point getRotado(Point P, double ang) {
double x = P.x * cos(ang) - P.y * sin(ang);
double y = P.x * sin(ang) + P.y * cos(ang);
return Point(x, y);
}
bool onSegment(Point A, Point B, Point C) {
bool ok = 0;
if (fabs(cross(B - A, C - A)) < 1e-8) ok = 1;
if (ok) {
double minx = min(A.x, B.x), maxx = max(A.x, B.x);
double miny = min(A.y, B.y), maxy = max(A.y, B.y);
return C.x + 1e-8 >= minx && C.x <= maxx + 1e-8 && C.y + 1e-8 >= miny &&
C.y <= maxy + 1e-8;
}
return 0;
}
bool interSegment(Point P1, Point P2, Point P3, Point P4) {
double A1 = cross(P2 - P1, P3 - P1);
double A2 = cross(P2 - P1, P4 - P1);
double A3 = cross(P4 - P3, P2 - P3);
double A4 = cross(P4 - P3, P1 - P3);
if (((A1 > 0 && A2 < 0) || (A1 < 0 && A2 > 0)) &&
((A3 > 0 && A4 < 0) || (A3 < 0 && A4 > 0)))
return 1;
if (onSegment(P2, P1, P3)) return 1;
if (onSegment(P2, P1, P4)) return 1;
if (onSegment(P3, P4, P1)) return 1;
if (onSegment(P3, P4, P2)) return 1;
return 0;
}
Point lineIntersection(Point A, Point B, Point C, Point D) {
double s = cross(C - A, D - C) / cross(B - A, D - C);
return A + s * (B - A);
}
double area(const vector<Point> &P) {
int n = P.size();
double A = 0;
for (int i = 1; i <= n - 2; i++) A += area(P[0], P[i], P[i + 1]);
return abs(A / 2);
}
vector<Point> ConvexHull(vector<Point> P) {
sort(P.begin(), P.end());
int n = P.size(), k = 0;
Point H[2 * n];
for (int i = 0; i < n; ++i) {
while (k >= 2 && area(H[k - 2], H[k - 1], P[i]) <= 0) --k;
H[k++] = P[i];
}
for (int i = n - 2, t = k; i >= 0; --i) {
while (k > t && area(H[k - 2], H[k - 1], P[i]) <= 0) --k;
H[k++] = P[i];
}
return vector<Point>(H, H + k - 1);
}
int main() {
long long w, h, a;
cin >> w >> h >> a;
if (a == 0 || a == 180) {
printf("%.10lf\n", (double)(w * h));
} else {
Point P[4], PR[4];
double ang = (a * (2 * acos(0.0))) / 180;
P[0] = Point(w / 2.0, h / 2.0);
P[1] = Point(-w / 2.0, h / 2.0);
P[2] = Point(-w / 2.0, -h / 2.0);
P[3] = Point(w / 2.0, -h / 2.0);
for (int i = 0; i < 4; ++i) {
PR[i] = getRotado(P[i], ang);
}
vector<Point> Polig;
for (int i = 0; i < 4; ++i) {
for (int j = 0; j < 4; ++j) {
if (interSegment(P[i], P[(i + 1) % 4], PR[j], PR[(j + 1) % 4])) {
Polig.push_back(
lineIntersection(P[i], P[(i + 1) % 4], PR[j], PR[(j + 1) % 4]));
}
}
}
vector<Point> Convex = ConvexHull(Polig);
printf("%.10lf\n", area(Convex));
}
}
``` |
### Prompt
Generate a CPP solution to the following problem:
An n × n square matrix is special, if:
* it is binary, that is, each cell contains either a 0, or a 1;
* the number of ones in each row and column equals 2.
You are given n and the first m rows of the matrix. Print the number of special n × n matrices, such that the first m rows coincide with the given ones.
As the required value can be rather large, print the remainder after dividing the value by the given number mod.
Input
The first line of the input contains three integers n, m, mod (2 ≤ n ≤ 500, 0 ≤ m ≤ n, 2 ≤ mod ≤ 109). Then m lines follow, each of them contains n characters — the first rows of the required special matrices. Each of these lines contains exactly two characters '1', the rest characters are '0'. Each column of the given m × n table contains at most two numbers one.
Output
Print the remainder after dividing the required value by number mod.
Examples
Input
3 1 1000
011
Output
2
Input
4 4 100500
0110
1010
0101
1001
Output
1
Note
For the first test the required matrices are:
011
101
110
011
110
101
In the second test the required matrix is already fully given, so the answer is 1.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long inf = 2147383647;
const double pi = 2 * acos(0.0);
const double eps = 1e-9;
struct debugger {
template <typename T>
debugger& operator,(const T& v) {
cerr << v << " ";
return *this;
}
} dbg;
inline long long gcd(long long a, long long b) {
a = ((a) < 0 ? -(a) : (a));
b = ((b) < 0 ? -(b) : (b));
while (b) {
a = a % b;
swap(a, b);
}
return a;
}
int ext_gcd(int a, int b, int& x, int& y) {
if (a == 0) {
x = 0;
y = 1;
return b;
}
int x1, y1;
int d = ext_gcd(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
return d;
}
inline long long modInv(int a, int m) {
int x, y;
ext_gcd(a, m, x, y);
return x;
}
inline long long power(long long a, long long p) {
long long res = 1, x = a;
while (p) {
if (p & 1) res = (res * x);
x = (x * x);
p >>= 1;
}
return res;
}
inline long long bigmod(long long a, long long p, long long m) {
long long res = 1, x = a % m;
while (p) {
if (p & 1) res = (res * x) % m;
x = (x * x) % m;
p >>= 1;
}
return res;
}
int n, m, mod;
char buf[1010][1010];
long long memo[510][510];
long long dp(int row, int zero, int one) {
if (row == n) {
if (zero == 0 && one == 0)
return 1;
else
return 0;
}
if (memo[zero][one] != -1) return memo[zero][one];
long long res = 0;
if (zero >= 2) {
res += ((zero * (zero - 1)) / 2) * dp(row + 1, zero - 2, one + 2);
res %= mod;
}
if (zero && one) {
res += zero * one * dp(row + 1, zero - 1, one);
res %= mod;
}
if (one >= 2) {
res += ((one * (one - 1)) / 2) * dp(row + 1, zero, one - 2);
res %= mod;
}
memo[zero][one] = res;
return res;
}
int main() {
memset(memo, -1, sizeof(memo));
scanf("%d %d %d", &n, &m, &mod);
int zero = 0, one = 0;
for (int i = (0); i <= (m - 1); ++i) {
for (int j = (0); j <= (n - 1); ++j) {
scanf(" %c", &buf[i][j]);
}
}
for (int i = (0); i <= (n - 1); ++i) {
int bit = 0;
for (int j = (0); j <= (m - 1); ++j) {
if (buf[j][i] == '1') bit++;
}
if (bit == 0)
zero++;
else if (bit == 1)
one++;
}
long long res = dp(m, zero, one);
printf("%I64d\n", res);
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
Robbers, who attacked the Gerda's cab, are very successful in covering from the kingdom police. To make the goal of catching them even harder, they use their own watches.
First, as they know that kingdom police is bad at math, robbers use the positional numeral system with base 7. Second, they divide one day in n hours, and each hour in m minutes. Personal watches of each robber are divided in two parts: first of them has the smallest possible number of places that is necessary to display any integer from 0 to n - 1, while the second has the smallest possible number of places that is necessary to display any integer from 0 to m - 1. Finally, if some value of hours or minutes can be displayed using less number of places in base 7 than this watches have, the required number of zeroes is added at the beginning of notation.
Note that to display number 0 section of the watches is required to have at least one place.
Little robber wants to know the number of moments of time (particular values of hours and minutes), such that all digits displayed on the watches are distinct. Help her calculate this number.
Input
The first line of the input contains two integers, given in the decimal notation, n and m (1 ≤ n, m ≤ 109) — the number of hours in one day and the number of minutes in one hour, respectively.
Output
Print one integer in decimal notation — the number of different pairs of hour and minute, such that all digits displayed on the watches are distinct.
Examples
Input
2 3
Output
4
Input
8 2
Output
5
Note
In the first sample, possible pairs are: (0: 1), (0: 2), (1: 0), (1: 2).
In the second sample, possible pairs are: (02: 1), (03: 1), (04: 1), (05: 1), (06: 1).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int ans;
int cnt1, cnt2;
int vis[10];
int n, m;
int getNum(int x) {
int cnt = 1;
while (x >= 7) {
x /= 7;
cnt++;
}
return cnt;
}
void dfs(int d, int sum) {
if (d > cnt1 + cnt2) return;
if (d <= cnt1 && sum >= n) return;
if (d > cnt1 && sum >= m) return;
if (d == cnt1 + cnt2) {
ans++;
return;
}
for (int i = 0; i < 7; i++) {
if (!vis[i]) {
vis[i] = 1;
if (d == cnt1)
dfs(d + 1, i);
else
dfs(d + 1, sum * 7 + i);
vis[i] = 0;
}
}
}
int main() {
scanf("%d%d", &n, &m);
cnt1 = getNum(n - 1), cnt2 = getNum(m - 1);
if (n == 1) cnt1 = 1;
if (m == 1) cnt2 = 1;
if (cnt1 + cnt2 > 7)
printf("0\n");
else {
dfs(0, 0);
printf("%d\n", ans);
}
return 0;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
Yura is tasked to build a closed fence in shape of an arbitrary non-degenerate simple quadrilateral. He's already got three straight fence segments with known lengths a, b, and c. Now he needs to find out some possible integer length d of the fourth straight fence segment so that he can build the fence using these four segments. In other words, the fence should have a quadrilateral shape with side lengths equal to a, b, c, and d. Help Yura, find any possible length of the fourth side.
A non-degenerate simple quadrilateral is such a quadrilateral that no three of its corners lie on the same line, and it does not cross itself.
Input
The first line contains a single integer t — the number of test cases (1 ≤ t ≤ 1000). The next t lines describe the test cases.
Each line contains three integers a, b, and c — the lengths of the three fence segments (1 ≤ a, b, c ≤ 10^9).
Output
For each test case print a single integer d — the length of the fourth fence segment that is suitable for building the fence. If there are multiple answers, print any. We can show that an answer always exists.
Example
Input
2
1 2 3
12 34 56
Output
4
42
Note
We can build a quadrilateral with sides 1, 2, 3, 4.
We can build a quadrilateral with sides 12, 34, 56, 42.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin >> t;
while (t--) {
vector<long long int> a(3);
cin >> a[0] >> a[1] >> a[2];
sort(a.begin(), a.end());
cout << a[2] << endl;
}
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
You are given an array a_1, a_2, ... , a_n. Array is good if for each pair of indexes i < j the condition j - a_j ≠ i - a_i holds. Can you shuffle this array so that it becomes good? To shuffle an array means to reorder its elements arbitrarily (leaving the initial order is also an option).
For example, if a = [1, 1, 3, 5], then shuffled arrays [1, 3, 5, 1], [3, 5, 1, 1] and [5, 3, 1, 1] are good, but shuffled arrays [3, 1, 5, 1], [1, 1, 3, 5] and [1, 1, 5, 3] aren't.
It's guaranteed that it's always possible to shuffle an array to meet this condition.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
The first line of each test case contains one integer n (1 ≤ n ≤ 100) — the length of array a.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 100).
Output
For each test case print the shuffled version of the array a which is good.
Example
Input
3
1
7
4
1 1 3 5
6
3 2 1 5 6 4
Output
7
1 5 1 3
2 4 6 1 3 5
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int a[105];
int main() {
int T, n, i, j;
cin >> T;
while (T--) {
cin >> n;
for (i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (i = n - 1; i >= 0; --i) cout << a[i] << " ";
cout << endl;
}
return 0;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
Attention: we lost all the test cases for this problem, so instead of solving the problem, we need you to generate test cases. We're going to give you the answer, and you need to print a test case that produces the given answer. The original problem is in the following paragraph.
People don't use cash as often as they used to. Having a credit card solves some of the hassles of cash, such as having to receive change when you can't form the exact amount of money needed to purchase an item. Typically cashiers will give you as few coins as possible in change, but they don't have to. For example, if your change is 30 cents, a cashier could give you a 5 cent piece and a 25 cent piece, or they could give you three 10 cent pieces, or ten 1 cent pieces, two 5 cent pieces, and one 10 cent piece. Altogether there are 18 different ways to make 30 cents using only 1 cent pieces, 5 cent pieces, 10 cent pieces, and 25 cent pieces. Two ways are considered different if they contain a different number of at least one type of coin. Given the denominations of the coins and an amount of change to be made, how many different ways are there to make change?
As we mentioned before, we lost all the test cases for this problem, so we're actually going to give you the number of ways, and want you to produce a test case for which the number of ways is the given number. There could be many ways to achieve this (we guarantee there's always at least one), so you can print any, as long as it meets the constraints described below.
Input
Input will consist of a single integer A (1 ≤ A ≤ 105), the desired number of ways.
Output
In the first line print integers N and M (1 ≤ N ≤ 106, 1 ≤ M ≤ 10), the amount of change to be made, and the number of denominations, respectively.
Then print M integers D1, D2, ..., DM (1 ≤ Di ≤ 106), the denominations of the coins. All denominations must be distinct: for any i ≠ j we must have Di ≠ Dj.
If there are multiple tests, print any of them. You can print denominations in atbitrary order.
Examples
Input
18
Output
30 4
1 5 10 25
Input
3
Output
20 2
5 2
Input
314
Output
183 4
6 5 2 139
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int res = n * 5 - 5;
if (res == 0) res = 1;
cout << res << ' ' << 2 << "\n";
cout << 1 << ' ' << 5;
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
Today on a lecture about strings Gerald learned a new definition of string equivalency. Two strings a and b of equal length are called equivalent in one of the two cases:
1. They are equal.
2. If we split string a into two halves of the same size a1 and a2, and string b into two halves of the same size b1 and b2, then one of the following is correct:
1. a1 is equivalent to b1, and a2 is equivalent to b2
2. a1 is equivalent to b2, and a2 is equivalent to b1
As a home task, the teacher gave two strings to his students and asked to determine if they are equivalent.
Gerald has already completed this home task. Now it's your turn!
Input
The first two lines of the input contain two strings given by the teacher. Each of them has the length from 1 to 200 000 and consists of lowercase English letters. The strings have the same length.
Output
Print "YES" (without the quotes), if these two strings are equivalent, and "NO" (without the quotes) otherwise.
Examples
Input
aaba
abaa
Output
YES
Input
aabb
abab
Output
NO
Note
In the first sample you should split the first string into strings "aa" and "ba", the second one — into strings "ab" and "aa". "aa" is equivalent to "aa"; "ab" is equivalent to "ba" as "ab" = "a" + "b", "ba" = "b" + "a".
In the second sample the first string can be splitted into strings "aa" and "bb", that are equivalent only to themselves. That's why string "aabb" is equivalent only to itself and to string "bbaa".
### Response
```cpp
#include <bits/stdc++.h>
const int INF = 2000000000;
const long long LLINF = 9000000000000000000LL;
const long double LDINF = 1e300;
using namespace std;
void lexosort(string& a, int s, int l) {
if (l % 2 == 1) return;
lexosort(a, s, l / 2);
lexosort(a, s + l / 2, l / 2);
bool swap = true;
for (int i = 0; i < l / 2; ++i) {
if (a[s + i] < a[s + i + l / 2]) {
swap = false;
break;
}
if (a[s + i] > a[s + i + l / 2]) {
swap = true;
break;
}
}
if (swap) {
for (int i = 0; i < l / 2; ++i) {
char tmp = a[s + i];
a[s + i] = a[s + i + l / 2];
a[s + i + l / 2] = tmp;
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
string a, b;
cin >> a >> b;
lexosort(a, 0, a.length());
lexosort(b, 0, b.length());
cout << (a == b ? "YES" : "NO") << endl;
return 0;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
The Berland Forest can be represented as an infinite cell plane. Every cell contains a tree. That is, contained before the recent events.
A destructive fire raged through the Forest, and several trees were damaged by it. Precisely speaking, you have a n × m rectangle map which represents the damaged part of the Forest. The damaged trees were marked as "X" while the remaining ones were marked as ".". You are sure that all burnt trees are shown on the map. All the trees outside the map are undamaged.
The firemen quickly extinguished the fire, and now they are investigating the cause of it. The main version is that there was an arson: at some moment of time (let's consider it as 0) some trees were set on fire. At the beginning of minute 0, only the trees that were set on fire initially were burning. At the end of each minute, the fire spread from every burning tree to each of 8 neighboring trees. At the beginning of minute T, the fire was extinguished.
The firemen want to find the arsonists as quickly as possible. The problem is, they know neither the value of T (how long the fire has been raging) nor the coordinates of the trees that were initially set on fire. They want you to find the maximum value of T (to know how far could the arsonists escape) and a possible set of trees that could be initially set on fire.
Note that you'd like to maximize value T but the set of trees can be arbitrary.
Input
The first line contains two integer n and m (1 ≤ n, m ≤ 10^6, 1 ≤ n ⋅ m ≤ 10^6) — the sizes of the map.
Next n lines contain the map. The i-th line corresponds to the i-th row of the map and contains m-character string. The j-th character of the i-th string is "X" if the corresponding tree is burnt and "." otherwise.
It's guaranteed that the map contains at least one "X".
Output
In the first line print the single integer T — the maximum time the Forest was on fire. In the next n lines print the certificate: the map (n × m rectangle) where the trees that were set on fire are marked as "X" and all other trees are marked as ".".
Examples
Input
3 6
XXXXXX
XXXXXX
XXXXXX
Output
1
......
.X.XX.
......
Input
10 10
.XXXXXX...
.XXXXXX...
.XXXXXX...
.XXXXXX...
.XXXXXXXX.
...XXXXXX.
...XXXXXX.
...XXXXXX.
...XXXXXX.
..........
Output
2
..........
..........
...XX.....
..........
..........
..........
.....XX...
..........
..........
..........
Input
4 5
X....
..XXX
..XXX
..XXX
Output
0
X....
..XXX
..XXX
..XXX
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline const T read1() {
T m = 0;
char k = getchar();
while (('0' > k || k > '9') && (k != '-')) k = getchar();
const bool f = (k == '-' ? 1 : 0);
if (f) k = getchar();
while ('0' <= k && k <= '9')
m = (m << 3) + (m << 1) + (k ^ 48), k = getchar();
return f ? -m : m;
}
int s, m, **a, t;
char **str;
bool **vis, **h;
queue<pair<int, int> > q;
bool judge(int n) {
while (!q.empty()) q.pop();
int len = n << 1 | 1, op = 0;
for (int i = 1; i <= s; ++i)
for (int j = 1; j <= m; ++j) vis[i][j] = h[i][j];
for (int i = 1; i <= s - len + 1; ++i)
for (int j = 1; j <= m - len + 1; ++j)
if (!(a[i + len - 1][j + len - 1] - a[i - 1][j + len - 1] -
a[i + len - 1][j - 1] + a[i - 1][j - 1]))
q.push(make_pair(i + n, j + n)), ++op, vis[i + n][j + n] = 1;
for (int i = 1; i <= n; ++i) {
int k = q.size();
while (k--) {
int x = q.front().first, y = q.front().second;
q.pop();
for (int tx = -1; tx <= 1; ++tx)
for (int ty = -1; ty <= 1; ++ty)
if (x + tx && x + tx <= s && y + ty && y + ty <= m &&
!vis[x + tx][y + ty]) {
vis[x + tx][y + ty] = 1;
q.push(make_pair(x + tx, y + ty));
++op;
}
}
}
return op == t;
}
int main() {
s = read1<int>(), m = read1<int>();
str = new char *[s + 5];
a = new int *[s + 5];
vis = new bool *[s + 5];
h = new bool *[s + 5];
a[0] = new int[m + 5]();
vis[0] = new bool[m + 5]();
h[0] = new bool[m + 5]();
for (int i = 1; i <= s; ++i) {
str[i] = new char[m + 5];
vis[i] = new bool[m + 5]();
h[i] = new bool[m + 5]();
a[i] = new int[m + 5]();
scanf("%s", str[i] + 1);
for (int j = 1; j <= m; ++j)
a[i][j] = a[i - 1][j] + a[i][j - 1] - a[i - 1][j - 1] +
(h[i][j] = str[i][j] == '.'),
t += str[i][j] == 'X';
}
int l = 1, r = min(s, m) - 1 >> 1, ans = 0, mid;
while (l <= r) judge(mid = l + r >> 1) ? ans = mid, l = mid + 1 : r = mid - 1;
printf("%d\n", ans);
for (int i = 1; i <= s; ++i)
for (int j = 1; j <= m; ++j) vis[i][j] = 0;
int len = ans << 1 | 1;
for (int i = 1; i <= s - len + 1; ++i)
for (int j = 1; j <= m - len + 1; ++j)
if (!(a[i + len - 1][j + len - 1] - a[i - 1][j + len - 1] -
a[i + len - 1][j - 1] + a[i - 1][j - 1]))
vis[i + ans][j + ans] = 1;
for (int i = 1; i <= s; ++i, putchar('\n'))
for (int j = 1; j <= m; ++j) putchar(vis[i][j] ? 'X' : '.');
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
There are n people in a row. The height of the i-th person is a_i. You can choose any subset of these people and try to arrange them into a balanced circle.
A balanced circle is such an order of people that the difference between heights of any adjacent people is no more than 1. For example, let heights of chosen people be [a_{i_1}, a_{i_2}, ..., a_{i_k}], where k is the number of people you choose. Then the condition |a_{i_j} - a_{i_{j + 1}}| ≤ 1 should be satisfied for all j from 1 to k-1 and the condition |a_{i_1} - a_{i_k}| ≤ 1 should be also satisfied. |x| means the absolute value of x. It is obvious that the circle consisting of one person is balanced.
Your task is to choose the maximum number of people and construct a balanced circle consisting of all chosen people. It is obvious that the circle consisting of one person is balanced so the answer always exists.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of people.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 2 ⋅ 10^5), where a_i is the height of the i-th person.
Output
In the first line of the output print k — the number of people in the maximum balanced circle.
In the second line print k integers res_1, res_2, ..., res_k, where res_j is the height of the j-th person in the maximum balanced circle. The condition |res_{j} - res_{j + 1}| ≤ 1 should be satisfied for all j from 1 to k-1 and the condition |res_{1} - res_{k}| ≤ 1 should be also satisfied.
Examples
Input
7
4 3 5 1 2 2 1
Output
5
2 1 1 2 3
Input
5
3 7 5 1 5
Output
2
5 5
Input
3
5 1 4
Output
2
4 5
Input
7
2 2 3 2 1 2 2
Output
7
1 2 2 2 2 3 2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
vector<long long> v(n + 1, 0), freq(200001 + 1, 0), one(200001 + 1, 0),
two(200001 + 1, 0), f(200001 + 1, 0);
for (unsigned long long i = 1; i < n + 1; i++) cin >> v[i], freq[v[i]]++;
f = freq;
for (int i = 1; i < 200001; i++) {
one[i] += one[i - 1];
two[i] += two[i - 1];
if (freq[i])
one[i]++;
else
one[i] = 0;
if (freq[i] > 1)
two[i]++;
else
two[i] = 0;
}
for (unsigned long long i = 1; i < 200001; i++) freq[i] += freq[i - 1];
long long mx, r, l;
mx = 0;
r = 0;
l = 0;
for (int i = 1; i < 200001; i++) {
int maybe = freq[i + 1];
if (i - two[i] - 1 >= 0) maybe -= freq[i - two[i] - 1];
if (maybe > mx) {
mx = maybe;
r = i + (one[i + 1] != 0);
l = i - two[i] + 1 - (one[i - two[i]] != 0);
}
}
cout << mx << endl;
for (int i = l; i <= r; i++) {
for (int j = 0; j < f[i] - 1; j++) cout << i << " ";
}
for (int i = r; i >= l; i--) {
cout << i << " ";
}
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
Little girl Susie went shopping with her mom and she wondered how to improve service quality.
There are n people in the queue. For each person we know time ti needed to serve him. A person will be disappointed if the time he waits is more than the time needed to serve him. The time a person waits is the total time when all the people who stand in the queue in front of him are served. Susie thought that if we swap some people in the queue, then we can decrease the number of people who are disappointed.
Help Susie find out what is the maximum number of not disappointed people can be achieved by swapping people in the queue.
Input
The first line contains integer n (1 ≤ n ≤ 105).
The next line contains n integers ti (1 ≤ ti ≤ 109), separated by spaces.
Output
Print a single number — the maximum number of not disappointed people in the queue.
Examples
Input
5
15 2 1 5 3
Output
4
Note
Value 4 is achieved at such an arrangement, for example: 1, 2, 3, 5, 15. Thus, you can make everything feel not disappointed except for the person with time 5.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
;
int t;
cin >> t;
long long arr[t], ar[t];
for (int i = 0; i < t; i++) {
cin >> arr[i];
}
sort(arr, arr + t);
int cnt = 1;
long long tmp;
ar[0] = arr[0];
int j = 1;
for (int i = 1; i < t; i++) {
if (arr[i] >= ar[j - 1]) {
tmp = ar[j - 1] + arr[i];
cnt++;
ar[j] = tmp;
j++;
}
}
cout << cnt << endl;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
Permutation p is an ordered set of integers p1, p2, ..., pn, consisting of n distinct positive integers, each of them doesn't exceed n. We'll denote the i-th element of permutation p as pi. We'll call number n the size or the length of permutation p1, p2, ..., pn.
We'll call position i (1 ≤ i ≤ n) in permutation p1, p2, ..., pn good, if |p[i] - i| = 1. Count the number of permutations of size n with exactly k good positions. Print the answer modulo 1000000007 (109 + 7).
Input
The single line contains two space-separated integers n and k (1 ≤ n ≤ 1000, 0 ≤ k ≤ n).
Output
Print the number of permutations of length n with exactly k good positions modulo 1000000007 (109 + 7).
Examples
Input
1 0
Output
1
Input
2 1
Output
0
Input
3 2
Output
4
Input
4 1
Output
6
Input
7 4
Output
328
Note
The only permutation of size 1 has 0 good positions.
Permutation (1, 2) has 0 good positions, and permutation (2, 1) has 2 positions.
Permutations of size 3:
1. (1, 2, 3) — 0 positions
2. <image> — 2 positions
3. <image> — 2 positions
4. <image> — 2 positions
5. <image> — 2 positions
6. (3, 2, 1) — 0 positions
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1010;
const long long mo = 1000000007;
int n, m;
long long f[maxn], g[maxn], c[maxn][maxn], dp[maxn][maxn][2][2];
int main() {
while (scanf("%d%d", &n, &m) != EOF) {
memset(g, 0, sizeof(g));
memset(f, 0, sizeof(f));
memset(c, 0, sizeof(c));
memset(dp, 0, sizeof(dp));
for (int i = 0; i <= n; ++i) dp[i][0][0][0] = 1;
f[0] = 1;
for (int i = 1; i <= n; ++i) f[i] = f[i - 1] * i % mo;
for (int i = 0; i <= n; ++i) c[i][0] = c[i][i] = 1;
for (int i = 0; i <= n; ++i)
for (int j = 1; j < n; ++j)
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % mo;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= i; ++j) {
if (i > 1)
dp[i][j][0][0] = (dp[i - 1][j][0][0] + dp[i - 1][j][1][0] +
dp[i - 1][j - 1][0][0]) %
mo;
dp[i][j][1][0] =
(dp[i - 1][j][0][1] + dp[i - 1][j][1][1] + dp[i - 1][j - 1][0][1]) %
mo;
if (i < n) {
dp[i][j][0][1] =
(dp[i - 1][j - 1][0][0] + dp[i - 1][j - 1][1][0]) % mo;
dp[i][j][1][1] =
(dp[i - 1][j - 1][0][1] + dp[i - 1][j - 1][1][1]) % mo;
}
}
for (int i = 0; i <= n; ++i)
g[i] =
(dp[n][i][0][0] + dp[n][i][0][1] + dp[n][i][1][0] + dp[n][i][1][1]) *
f[n - i] % mo;
long long ans = 0;
for (int i = 0; i <= n - m; ++i)
ans = (ans + c[m + i][m] * g[m + i] * (i & 1 ? -1 : 1) + mo) % mo;
printf("%I64d\n", ans);
}
return 0;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
Example
Input
ACM
Output
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
#define REP(i,a,b) for(int i=a;i<(int)b;i++)
#define rep(i,n) REP(i,0,n)
#define all(c) (c).begin(), (c).end()
#define zero(a) memset(a, 0, sizeof a)
#define minus(a) memset(a, -1, sizeof a)
#define watch(a) { cout << #a << " = " << a << endl; }
template<class T1, class T2> inline bool minimize(T1 &a, T2 b) { return b < a && (a = b, 1); }
template<class T1, class T2> inline bool maximize(T1 &a, T2 b) { return a < b && (a = b, 1); }
typedef long long ll;
int const inf = 1<<29;
string S;
int idx;
int N, M;
string alphas;
int curr;
bool try_consume(char c) {
if(S[idx] != c) return false;
idx ++;
return true;
}
int E();
int convert(string const& b) {
int n = b.size();
int ret = 0;
for(int i=0; i<n; i++) {
ret *= 2;
assert(isdigit(b[i]));
ret += b[i] - '0';
}
return ret;
}
string B() {
string ret;
while(1) {
if(S[idx] == '0') ret += '0';
else if(S[idx] == '1') ret += '1';
else break;
idx++;
}
return ret;
}
int Nu() {
if(try_consume('0')) return 0;
if(!try_consume('1')) return -inf;
return convert("1" + B());
}
int F() {
if(try_consume('-')) {
int f = F();
if(f == -inf) return -inf;
return -f;
}
else if(try_consume('(')) {
int r = E();
if(!try_consume(')')) return -inf;
return r;
}
else {
return Nu();
}
}
int T() {
int num1 = F();
if(num1 == -inf) return -inf;
while(try_consume('*')) {
int num2 = F();
if(num2 == -inf) return -inf;
num1 *= num2;
}
return num1;
}
int E() {
int term1 = T();
if(term1 == -inf) return -inf;
while(1) {
bool cont = 0;
while(try_consume('+')) {
cont = 1;
int term2 = T();
if(term2 == -inf) return -inf;
term1 += term2;
}
while(try_consume('-')) {
cont = 1;
int term2 = T();
if(term2 == -inf) return -inf;
term1 -= term2;
}
if(!cont) break;
}
return term1;
}
bool Q() {
int expr1 = E();
if(expr1 == -inf) return false;
if(!try_consume('=')) return false;
int expr2 = E();
if(expr2 == -inf) return false;
return expr1 == expr2 && idx == N;
}
int main() {
string T = "01+-*()=";
sort(T.begin(), T.end());
string RS; cin >> RS;
N = RS.size();
for(auto c: RS) if(isalpha(c)) alphas.push_back(c);
sort(alphas.begin(), alphas.end());
alphas.erase(unique(alphas.begin(), alphas.end()), alphas.end());
M = alphas.size();
if(M > T.size()) {
cout << 0 << endl;
return 0;
}
int ans = 0;
set<string> st;
do {
S = RS;
rep(i, N) {
if(isalpha(S[i])) S[i] = T[alphas.find(S[i])];
}
if(!st.count(S)) {
st.insert(S);
idx = curr = 0;
ans += Q();
}
} while(next_permutation(T.begin(), T.end()));
cout << ans << endl;
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
It is dark times in Berland. Berlyand opposition, funded from a neighboring state, has organized a demonstration in Berland capital Bertown. Through the work of intelligence we know that the demonstrations are planned to last for k days.
Fortunately, Berland has a special police unit, which can save the country. It has exactly n soldiers numbered from 1 to n. Berland general, the commander of the detachment, must schedule the detachment's work in these difficult k days. In each of these days, the general must send a certain number of police officers to disperse riots. Since the detachment is large and the general is not very smart, he can only select a set of all soldiers numbered from l to r, inclusive, where l and r are selected arbitrarily.
Now the general has exactly two problems. First, he cannot send the same group twice — then soldiers get bored and they rebel. Second, not all soldiers are equally reliable. Every soldier has a reliability of ai. The reliability of the detachment is counted as the sum of reliabilities of soldiers in it. The reliability of a single soldier can be negative, then when you include him in the detachment, he will only spoil things. The general is distinguished by his great greed and shortsightedness, so each day he sends to the dissolution the most reliable group of soldiers possible (that is, of all the groups that have not been sent yet).
The Berland Government has decided to know what would be the minimum reliability of the detachment, sent to disperse the demonstrations during these k days. The general himself can not cope with such a difficult task. Help him to not embarrass himself in front of his superiors!
Input
The first line contains two integers n and k <image> — the number of soldiers in the detachment and the number of times somebody goes on duty.
The second line contains n space-separated integers ai, their absolute value doesn't exceed 109 — the soldiers' reliabilities.
Please do not use the %lld specifier to read or write 64-bit integers in С++, it is preferred to use cin, cout streams of the %I64d specifier.
Output
Print a single number — the sought minimum reliability of the groups that go on duty during these k days.
Examples
Input
3 4
1 4 2
Output
4
Input
4 6
2 -1 2 -1
Output
1
Input
8 10
1 -2 3 -4 5 -6 7 -8
Output
2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
struct Poi {
long long x;
int y;
bool operator<(const Poi& i) const {
if (x == i.x) return y < i.y;
return x < i.x;
}
} s[maxn];
int N, d[maxn], te, a[maxn];
int lowbit(int x) { return x & (-x); }
void ser(int v) {
for (int i = v; i; i -= lowbit(i)) te += d[i];
}
void inser(int v) {
for (int i = v; i <= N; i += lowbit(i)) ++d[i];
}
long long calc(long long limit) {
memset(d, 0, sizeof(d));
int t(1);
long long ans(0);
for (int i = 1; i <= N; ++i) {
while (t <= N && s[i].x - s[t].x >= limit) inser(s[t++].y);
te = 0;
if (s[i].y != 1) ser(s[i].y - 1);
ans += te;
}
return ans;
}
int main() {
long long K;
cin >> N >> K;
++N;
for (int i = 2; i <= N; ++i) scanf("%d", &a[i]);
s[1].x = 0;
for (int i = 1; i <= N; ++i) s[i].x = s[i - 1].x + a[i];
for (int i = 1; i <= N; ++i) s[i].y = i;
sort(s + 1, s + 1 + N);
long long l = 0, r = 0;
for (int i = 1; i <= N; ++i) (a[i] < 0) ? l += a[i] : r += a[i];
long long mid = (l + r) >> 1, ans(-1);
for (; l <= r; mid = (l + r) >> 1)
if (calc(mid) >= K)
l = mid + 1, ans = mid;
else
r = mid - 1;
cout << ans << endl;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
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;
const long long mxx = 1e5 + 7;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int tt;
cin >> tt;
while (tt--) {
int n;
cin >> n;
int a[n];
int sum = 0, mx = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
mx = max(mx, a[i]);
}
if (n == 1) {
cout << "T"
<< "\n";
} else if (n == 2) {
if (a[0] == a[1])
cout << "HL\n";
else
cout << "T\n";
} else {
if (mx > sum - mx || sum % 2)
cout << "T\n";
else
cout << "HL\n";
}
}
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
You still have partial information about the score during the historic football match. You are given a set of pairs (a_i, b_i), indicating that at some point during the match the score was "a_i: b_i". It is known that if the current score is «x:y», then after the goal it will change to "x+1:y" or "x:y+1". What is the largest number of times a draw could appear on the scoreboard?
The pairs "a_i:b_i" are given in chronological order (time increases), but you are given score only for some moments of time. The last pair corresponds to the end of the match.
Input
The first line contains a single integer n (1 ≤ n ≤ 10000) — the number of known moments in the match.
Each of the next n lines contains integers a_i and b_i (0 ≤ a_i, b_i ≤ 10^9), denoting the score of the match at that moment (that is, the number of goals by the first team and the number of goals by the second team).
All moments are given in chronological order, that is, sequences x_i and y_j are non-decreasing. The last score denotes the final result of the match.
Output
Print the maximum number of moments of time, during which the score was a draw. The starting moment of the match (with a score 0:0) is also counted.
Examples
Input
3
2 0
3 1
3 4
Output
2
Input
3
0 0
0 0
0 0
Output
1
Input
1
5 4
Output
5
Note
In the example one of the possible score sequences leading to the maximum number of draws is as follows: 0:0, 1:0, 2:0, 2:1, 3:1, 3:2, 3:3, 3:4.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long n;
pair<int, int> a[10005];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
long long ans = 1;
long long xx = 0, yy = 0;
for (int i = 0; i < n; ++i) {
long long x, y;
cin >> x >> y;
long long mx = max(xx, yy);
long long mn = min(x, y);
if (mn >= mx) ans += mn - mx + (xx != yy);
xx = x;
yy = y;
}
cout << ans;
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
We have N gemstones labeled 1 through N.
You can perform the following operation any number of times (possibly zero).
* Select a positive integer x, and smash all the gems labeled with multiples of x.
Then, for each i, if the gem labeled i remains without getting smashed, you will receive a_i yen (the currency of Japan). However, a_i may be negative, in which case you will be charged money.
By optimally performing the operation, how much yen can you earn?
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* |a_i| \leq 10^9
Input
Input is given from Standard Input in the following format:
N
a_1 a_2 ... a_N
Output
Print the maximum amount of money that can be earned.
Examples
Input
6
1 2 -6 4 5 3
Output
12
Input
6
100 -100 -100 -100 100 -100
Output
200
Input
5
-1 -2 -3 -4 -5
Output
0
Input
2
-1000 100000
Output
99000
### Response
```cpp
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define INF 1<<30
#define LINF 1LL<<60
struct edge {
int to; // 行き先
ll cap; // 容量
int rev; // 逆辺
edge() {}
edge(int to, ll cap, int rev) :to(to), cap(cap), rev(rev) {}
};
vector<vector<edge>> G; // グラフの隣接リスト表現
vector<int> used; // DFSですでに調べたらフラグ
// fromからtoへ向かう容量capの辺をグラフに追加する
void add_edge(int from, int to, ll cap) {
G[from].push_back(edge(to, cap, G[to].size()));
G[to].push_back(edge(from, 0, G[from].size() - 1));
}
// 増加パスをDFSで探す
ll dfs(int v, int t, ll f) {
if (v == t) return f;
used[v] = true;
for (int i = 0; i < G[v].size(); i++) {
edge &e = G[v][i];
if (!used[e.to] && e.cap > 0) {
ll d = dfs(e.to, t, min(f, e.cap));
if (d > 0) {
e.cap -= d;
G[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
// sからtへの最大流を求める
ll max_flow(int s, int t) {
ll flow = 0;
for (;;) {
fill(used.begin(), used.end(), 0);
ll f = dfs(s, t, INF);
if (f == 0) return flow;
flow += f;
}
}
int main(void) {
cin.tie(0); ios::sync_with_stdio(false);
ll N; cin >> N;
G.resize(N + 2); used.resize(N + 2);
ll Sum = 0;
for (int i = 1; i <= N;i++) {
ll a; cin >> a;
for (int j = 2 * i; j <= N; j += i) add_edge(i, j, LINF);
if (a > 0) {
Sum += a;
add_edge(i, N + 1, a);
}
else {
add_edge(0, i, -a);
}
}
cout << Sum - max_flow(0, N + 1) << endl;
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
problem
Five students, Taro, Jiro, Saburo, Shiro, and Hanako, participated in the JOI High School class.
In this class, a final exam was conducted. All five people took the final exam. For students with a final exam score of 40 or higher, the final exam score was used as is. All students with a final exam score of less than 40 received supplementary lessons and scored 40 points.
Create a program that calculates the average score of the five students' grades given the final exam scores of the five students.
Example
Input
10
65
100
30
95
Output
68
### Response
```cpp
#include <iostream>
using namespace std;
int main(){
int s=0;
int n=5;
while(n--){
int t; cin>>t;
s+=max(t,40);
}
cout<<s/5<<endl;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
There is little time left before the release of the first national operating system BerlOS. Some of its components are not finished yet — the memory manager is among them. According to the developers' plan, in the first release the memory manager will be very simple and rectilinear. It will support three operations:
* alloc n — to allocate n bytes of the memory and return the allocated block's identifier x;
* erase x — to erase the block with the identifier x;
* defragment — to defragment the free memory, bringing all the blocks as close to the beginning of the memory as possible and preserving their respective order;
The memory model in this case is very simple. It is a sequence of m bytes, numbered for convenience from the first to the m-th.
The first operation alloc n takes as the only parameter the size of the memory block that is to be allocated. While processing this operation, a free block of n successive bytes is being allocated in the memory. If the amount of such blocks is more than one, the block closest to the beginning of the memory (i.e. to the first byte) is prefered. All these bytes are marked as not free, and the memory manager returns a 32-bit integer numerical token that is the identifier of this block. If it is impossible to allocate a free block of this size, the function returns NULL.
The second operation erase x takes as its parameter the identifier of some block. This operation frees the system memory, marking the bytes of this block as free for further use. In the case when this identifier does not point to the previously allocated block, which has not been erased yet, the function returns ILLEGAL_ERASE_ARGUMENT.
The last operation defragment does not have any arguments and simply brings the occupied memory sections closer to the beginning of the memory without changing their respective order.
In the current implementation you are to use successive integers, starting with 1, as identifiers. Each successful alloc operation procession should return following number. Unsuccessful alloc operations do not affect numeration.
You are to write the implementation of the memory manager. You should output the returned value for each alloc command. You should also output ILLEGAL_ERASE_ARGUMENT for all the failed erase commands.
Input
The first line of the input data contains two positive integers t and m (1 ≤ t ≤ 100;1 ≤ m ≤ 100), where t — the amount of operations given to the memory manager for processing, and m — the available memory size in bytes. Then there follow t lines where the operations themselves are given. The first operation is alloc n (1 ≤ n ≤ 100), where n is an integer. The second one is erase x, where x is an arbitrary 32-bit integer numerical token. The third operation is defragment.
Output
Output the sequence of lines. Each line should contain either the result of alloc operation procession , or ILLEGAL_ERASE_ARGUMENT as a result of failed erase operation procession. Output lines should go in the same order in which the operations are processed. Successful procession of alloc operation should return integers, starting with 1, as the identifiers of the allocated blocks.
Examples
Input
6 10
alloc 5
alloc 3
erase 1
alloc 6
defragment
alloc 6
Output
1
2
NULL
3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long m, t, M[110];
long long id = 1;
void alc(long long n) {
for (long long i = 1; i <= m - n + 1; i++) {
long long j;
for (j = i; j < i + n; j++)
if (M[j]) break;
if (j < i + n) continue;
for (j = i; j < i + n; j++) M[j] = id;
cout << id++ << '\n';
return;
}
cout << "NULL\n";
}
void ers(long long n) {
long long cnt = 0;
for (long long i = 1; i <= 100; i++)
if (M[i] == n && M[i] >= 1 && M[i] <= 100) M[i] = 0, cnt++;
if (!cnt) cout << "ILLEGAL_ERASE_ARGUMENT\n";
}
void frg() {
vector<long long> v;
for (long long i = 1; i <= 100; i++)
if (M[i]) v.push_back(M[i]);
memset(M, 0, sizeof(M));
long long L = v.size();
for (long long i = 1; i <= L; i++) M[i] = v[i - 1];
}
int main() {
cin >> t >> m;
while (t--) {
string s;
cin >> s;
if (s == "alloc") {
long long x;
cin >> x;
alc(x);
}
if (s == "erase") {
long long x;
cin >> x;
ers(x);
}
if (s == "defragment") {
frg();
}
}
return 0;
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
Today is tuesday, that means there is a dispute in JOHNNY SOLVING team again: they try to understand who is Johnny and who is Solving. That's why guys asked Umnik to help them. Umnik gave guys a connected graph with n vertices without loops and multiedges, such that a degree of any vertex is at least 3, and also he gave a number 1 ≤ k ≤ n. Because Johnny is not too smart, he promised to find a simple path with length at least n/k in the graph. In reply, Solving promised to find k simple by vertices cycles with representatives, such that:
* Length of each cycle is at least 3.
* Length of each cycle is not divisible by 3.
* In each cycle must be a representative - vertex, which belongs only to this cycle among all printed cycles.
You need to help guys resolve the dispute, for that you need to find a solution for Johnny: a simple path with length at least n/k (n is not necessarily divided by k), or solution for Solving: k cycles that satisfy all the conditions above. If there is no any solution - print -1.
Input
The first line contains three integers n, m and k (1 ≤ k ≤ n ≤ 2.5 ⋅ 10^5, 1 ≤ m ≤ 5 ⋅ 10^5)
Next m lines describe edges of the graph in format v, u (1 ≤ v, u ≤ n). It's guaranteed that v ≠ u and all m pairs are distinct.
It's guaranteed that a degree of each vertex is at least 3.
Output
Print PATH in the first line, if you solve problem for Johnny. In the second line print the number of vertices in the path c (c ≥ n/k). And in the third line print vertices describing the path in route order.
Print CYCLES in the first line, if you solve problem for Solving. In the following lines describe exactly k cycles in the following format: in the first line print the size of the cycle c (c ≥ 3). In the second line print the cycle in route order. Also, the first vertex in the cycle must be a representative.
Print -1 if there is no any solution. The total amount of printed numbers in the output must be at most 10^6. It's guaranteed, that if exists any solution then there is a correct output satisfies this restriction.
Examples
Input
4 6 2
1 2
1 3
1 4
2 3
2 4
3 4
Output
PATH
4
1 2 3 4
Input
10 18 2
1 2
1 3
1 4
1 5
1 6
1 7
1 8
1 9
1 10
2 3
3 4
2 4
5 6
6 7
5 7
8 9
9 10
8 10
Output
CYCLES
4
4 1 2 3
4
7 1 5 6
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 1;
int n, k, m, a, b, u;
int t[N];
vector<int> v1[N];
vector<int> v[N];
vector<int> w[N];
bool odw[N];
int o[N];
int xd = -1;
int dd;
int dist[N];
vector<int> leafs;
void dfs1(int a, int d, int oj) {
odw[a] = true;
for (int i = 0; i < v1[a].size(); i++) {
u = v1[a][i];
if (!odw[u]) {
o[u] = a;
v[a].push_back(u);
dfs1(u, d + 1, a);
} else {
if (u != a) w[u].push_back(a);
}
}
if (d >= n / k + int(n % k == 0) && xd == -1) {
xd = a;
dd = d;
}
}
void dfs(int a) {
for (int i = 0; i < v[a].size(); i++) {
u = v[a][i];
dist[u] = dist[a] + 1;
dfs(u);
}
if (v[a].size() == 0) leafs.push_back(a);
}
int main() {
std::ios_base::sync_with_stdio(false);
cin >> n >> m >> k;
for (int i = 0; i < m; i++) {
cin >> a >> b;
v1[a].push_back(b);
v1[b].push_back(a);
}
dfs1(1, 1, -1);
if (xd != -1) {
cout << "PATH\n";
cout << dd << "\n";
vector<int> ans;
while (xd != 1) {
ans.push_back(xd);
xd = o[xd];
}
cout << 1 << " ";
for (int i = ans.size() - 1; i >= 0; i--) cout << ans[i] << " ";
return 0;
}
dfs(1);
dist[1] = 0;
cout << "CYCLES\n";
for (int id = 0; id < k; id++) {
int l = leafs[id], x = w[l][0], y = w[l][1];
if ((dist[l] - dist[x] + 1) % 3 != 0) {
cout << dist[l] - dist[x] + 1 << "\n";
while (l != x) {
cout << l << " ";
l = o[l];
}
cout << x << "\n";
} else if ((dist[l] - dist[y] + 1) % 3 != 0) {
cout << dist[l] - dist[y] + 1 << "\n";
while (l != y) {
cout << l << " ";
l = o[l];
}
cout << y << "\n";
} else {
if (dist[x] < dist[y]) swap(x, y);
cout << dist[x] - dist[y] + 2 << "\n";
cout << l << " ";
while (x != y) {
cout << x << " ";
x = o[x];
}
cout << y << "\n";
}
}
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
One night, having had a hard day at work, Petya saw a nightmare. There was a binary search tree in the dream. But it was not the actual tree that scared Petya. The horrifying thing was that Petya couldn't search for elements in this tree. Petya tried many times to choose key and look for it in the tree, and each time he arrived at a wrong place. Petya has been racking his brains for long, choosing keys many times, but the result was no better. But the moment before Petya would start to despair, he had an epiphany: every time he was looking for keys, the tree didn't have the key, and occured exactly one mistake. "That's not a problem!", thought Petya. "Why not count the expectation value of an element, which is found when I search for the key". The moment he was about to do just that, however, Petya suddenly woke up.
Thus, you are given a binary search tree, that is a tree containing some number written in the node. This number is called the node key. The number of children of every node of the tree is equal either to 0 or to 2. The nodes that have 0 children are called leaves and the nodes that have 2 children, are called inner. An inner node has the left child, that is the child whose key is less than the current node's key, and the right child, whose key is more than the current node's key. Also, a key of any node is strictly larger than all the keys of the left subtree of the node and strictly smaller than all the keys of the right subtree of the node.
Also you are given a set of search keys, all of which are distinct and differ from the node keys contained in the tree. For each key from the set its search in the tree is realised. The search is arranged like this: initially we are located in the tree root, if the key of the current node is larger that our search key, then we move to the left child of the node, otherwise we go to the right child of the node and the process is repeated. As it is guaranteed that the search key is not contained in the tree, the search will always finish in some leaf. The key lying in the leaf is declared the search result.
It is known for sure that during the search we make a mistake in comparing exactly once, that is we go the wrong way, but we won't make any mistakes later. All possible mistakes are equiprobable, that is we should consider all such searches where exactly one mistake occurs. Your task is to find the expectation (the average value) of the search result for every search key, considering that exactly one mistake occurs in the search. That is, for a set of paths containing exactly one mistake in the given key search, you should count the average value of keys containing in the leaves of those paths.
Input
The first line contains an odd integer n (3 ≤ n < 105), which represents the number of tree nodes. Next n lines contain node descriptions. The (i + 1)-th line contains two space-separated integers. The first number is the number of parent of the i-st node and the second number is the key lying in the i-th node. The next line contains an integer k (1 ≤ k ≤ 105), which represents the number of keys for which you should count the average value of search results containing one mistake. Next k lines contain the actual keys, one key per line.
All node keys and all search keys are positive integers, not exceeding 109. All n + k keys are distinct.
All nodes are numbered from 1 to n. For the tree root "-1" (without the quote) will be given instead of the parent's node number. It is guaranteed that the correct binary search tree is given. For each node except for the root, it could be determined according to its key whether it is the left child or the right one.
Output
Print k real numbers which are the expectations of answers for the keys specified in the input. The answer should differ from the correct one with the measure of absolute or relative error not exceeding 10 - 9.
Examples
Input
7
-1 8
1 4
1 12
2 2
2 6
3 10
3 14
1
1
Output
8.0000000000
Input
3
-1 5
1 3
1 7
6
1
2
4
6
8
9
Output
7.0000000000
7.0000000000
7.0000000000
3.0000000000
3.0000000000
3.0000000000
Note
In the first sample the search of key 1 with one error results in two paths in the trees: (1, 2, 5) and (1, 3, 6), in parentheses are listed numbers of nodes from the root to a leaf. The keys in the leaves of those paths are equal to 6 and 10 correspondingly, that's why the answer is equal to 8.
### Response
```cpp
#include <bits/stdc++.h>
void intIntSort(int d[], int m[], int s) {
int i = -1, j = s, k, t;
if (s <= 1) return;
k = (d[0] + d[s - 1]) / 2;
for (;;) {
while (d[++i] < k)
;
while (d[--j] > k)
;
if (i >= j) break;
t = d[i];
d[i] = d[j];
d[j] = t;
t = m[i];
m[i] = m[j];
m[j] = t;
}
intIntSort(d, m, i);
intIntSort(d + j + 1, m + j + 1, s - j - 1);
}
int n, qs;
int q[200000], q_ind[200000];
int root;
int left[200000], right[200000], up[200000], num[200000];
double sum[200000], per[200000];
int mi[200000], mx[200000];
int mx_node[200000], mn_node[200000];
int res_size;
double res[200000];
void pre_cal(int node) {
if (left[node] == -1) {
mx_node[node] = mn_node[node] = num[node];
return;
}
pre_cal(left[node]);
pre_cal(right[node]);
mn_node[node] = mn_node[left[node]];
mx_node[node] = mx_node[right[node]];
}
void solve(int node) {
int i, j, k;
int nx;
if (left[node] == -1) {
while (res_size < qs && mi[node] <= q[res_size] &&
q[res_size] <= mx[node]) {
res[q_ind[res_size]] = sum[node] / per[node];
res_size++;
}
return;
}
nx = left[node];
mi[nx] = mi[node];
mx[nx] = num[node] - 1;
sum[nx] = sum[node] + mn_node[right[node]];
per[nx] = per[node] + 1;
solve(nx);
nx = right[node];
mi[nx] = num[node] + 1;
mx[nx] = mx[node];
sum[nx] = sum[node] + mx_node[left[node]];
per[nx] = per[node] + 1;
solve(nx);
}
int main() {
int i, j, k, l, m;
while (scanf("%d", &n) == 1) {
for (i = 0; i < n; i++) scanf("%d%d", up + i, num + i), up[i]--;
scanf("%d", &qs);
for (i = 0; i < qs; i++) scanf("%d", q + i);
for (i = 0; i < n; i++) left[i] = right[i] = -1;
for (i = 0; i < n; i++) {
if (up[i] < 0) {
root = i;
continue;
}
if (num[i] < num[up[i]]) left[up[i]] = i;
if (num[i] > num[up[i]]) right[up[i]] = i;
}
for (i = 0; i < qs; i++) q_ind[i] = i;
intIntSort(q, q_ind, qs);
pre_cal(root);
res_size = 0;
mi[root] = -2000000000;
mx[root] = 2000000000;
solve(root);
for (i = 0; i < qs; i++) printf("%.10f\n", res[i]);
}
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
Little girl Margarita is a big fan of competitive programming. She especially loves problems about arrays and queries on them.
Recently, she was presented with an array a of the size of 10^9 elements that is filled as follows:
* a_1 = -1
* a_2 = 2
* a_3 = -3
* a_4 = 4
* a_5 = -5
* And so on ...
That is, the value of the i-th element of the array a is calculated using the formula a_i = i ⋅ (-1)^i.
She immediately came up with q queries on this array. Each query is described with two numbers: l and r. The answer to a query is the sum of all the elements of the array at positions from l to r inclusive.
Margarita really wants to know the answer to each of the requests. She doesn't want to count all this manually, but unfortunately, she couldn't write the program that solves the problem either. She has turned to you — the best programmer.
Help her find the answers!
Input
The first line contains a single integer q (1 ≤ q ≤ 10^3) — the number of the queries.
Each of the next q lines contains two integers l and r (1 ≤ l ≤ r ≤ 10^9) — the descriptions of the queries.
Output
Print q lines, each containing one number — the answer to the query.
Example
Input
5
1 3
2 5
5 5
4 4
2 3
Output
-2
-2
-5
4
-1
Note
In the first query, you need to find the sum of the elements of the array from position 1 to position 3. The sum is equal to a_1 + a_2 + a_3 = -1 + 2 -3 = -2.
In the second query, you need to find the sum of the elements of the array from position 2 to position 5. The sum is equal to a_2 + a_3 + a_4 + a_5 = 2 -3 + 4 - 5 = -2.
In the third query, you need to find the sum of the elements of the array from position 5 to position 5. The sum is equal to a_5 = -5.
In the fourth query, you need to find the sum of the elements of the array from position 4 to position 4. The sum is equal to a_4 = 4.
In the fifth query, you need to find the sum of the elements of the array from position 2 to position 3. The sum is equal to a_2 + a_3 = 2 - 3 = -1.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
while (q--) {
long long int l, r, sum1, sum2, x1, y1, x2, y2;
cin >> l >> r;
x1 = r / 2;
x1 = x1 * (x1 + 1);
x2 = (l - 1) / 2;
x2 = x2 * (x2 + 1);
sum1 = x1 - x2;
r = ceil(r / 2.0);
y1 = pow(r, 2);
l = ceil((l - 1) / 2.0);
y2 = pow(l, 2);
sum2 = (y1 - y2) * -1;
cout << sum1 + sum2 << endl;
}
return 0;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
Bajtek, known for his unusual gifts, recently got an integer array x_0, x_1, …, x_{k-1}.
Unfortunately, after a huge array-party with his extraordinary friends, he realized that he'd lost it. After hours spent on searching for a new toy, Bajtek found on the arrays producer's website another array a of length n + 1. As a formal description of a says, a_0 = 0 and for all other i (1 ≤ i ≤ n) a_i = x_{(i-1)mod k} + a_{i-1}, where p mod q denotes the remainder of division p by q.
For example, if the x = [1, 2, 3] and n = 5, then:
* a_0 = 0,
* a_1 = x_{0mod 3}+a_0=x_0+0=1,
* a_2 = x_{1mod 3}+a_1=x_1+1=3,
* a_3 = x_{2mod 3}+a_2=x_2+3=6,
* a_4 = x_{3mod 3}+a_3=x_0+6=7,
* a_5 = x_{4mod 3}+a_4=x_1+7=9.
So, if the x = [1, 2, 3] and n = 5, then a = [0, 1, 3, 6, 7, 9].
Now the boy hopes that he will be able to restore x from a! Knowing that 1 ≤ k ≤ n, help him and find all possible values of k — possible lengths of the lost array.
Input
The first line contains exactly one integer n (1 ≤ n ≤ 1000) — the length of the array a, excluding the element a_0.
The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^6).
Note that a_0 is always 0 and is not given in the input.
Output
The first line of the output should contain one integer l denoting the number of correct lengths of the lost array.
The second line of the output should contain l integers — possible lengths of the lost array in increasing order.
Examples
Input
5
1 2 3 4 5
Output
5
1 2 3 4 5
Input
5
1 3 5 6 8
Output
2
3 5
Input
3
1 5 3
Output
1
3
Note
In the first example, any k is suitable, since a is an arithmetic progression.
Possible arrays x:
* [1]
* [1, 1]
* [1, 1, 1]
* [1, 1, 1, 1]
* [1, 1, 1, 1, 1]
In the second example, Bajtek's array can have three or five elements.
Possible arrays x:
* [1, 2, 2]
* [1, 2, 2, 1, 2]
For example, k = 4 is bad, since it leads to 6 + x_0 = 8 and 0 + x_0 = 1, which is an obvious contradiction.
In the third example, only k = n is good.
Array [1, 4, -2] satisfies the requirements.
Note that x_i may be negative.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353;
const int N = 200005;
const double PI = 4 * atan(1);
const long long MAX = 9223372036854775807;
int dx[] = {1, -1, 0, 0, 1, -1, 1, -1};
int dy[] = {0, 0, 1, -1, 1, 1, -1, -1};
long long gcd(long long a, long long b) { return (b == 0 ? a : gcd(b, a % b)); }
long long lcm(long long a, long long b) { return a * (b / gcd(a, b)); }
bool issquare(long long w) { return trunc(sqrt(w)) * trunc(sqrt(w)) == w; }
bool isprime(long long u) {
for (long long i = 2; i <= (int)sqrt(u); i++) {
if (u % i == 0) return 0;
}
return 1;
}
long long mod(long long to_mod, long long MOD) {
to_mod %= MOD;
while (to_mod < 0) to_mod += MOD;
return to_mod % MOD;
}
long long moduloMultiplication(long long a, long long b, long long mod) {
long long res = 0;
a %= mod;
while (b) {
if (b & 1) res = (res + a) % mod;
a = (2 * a) % mod;
b >>= 1;
}
return res;
}
long long power(long long x, long long y) {
long long res = 1;
x = x;
while (y > 0) {
if (y & 1) res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
long long n, m, x, y, k, z, w, l, r, ans, res;
long long a[1005];
long long b[1005];
vector<long long> v;
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
a[0] = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i + 1];
}
for (int i = 1; i <= n; i++) {
b[i - 1] = a[i] - a[i - 1];
bool cond = true;
for (int j = 1; j <= n; j++) {
if (a[j] != b[(j - 1) % i] + a[j - 1]) {
cond = false;
}
}
if (cond) v.push_back(i);
}
cout << v.size() << endl;
for (auto t : v) {
cout << t << " ";
}
return 0;
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
You are given an array a of n positive integers.
You can use the following operation as many times as you like: select any integer 1 ≤ k ≤ n and do one of two things:
* decrement by one k of the first elements of the array.
* decrement by one k of the last elements of the array.
For example, if n=5 and a=[3,2,2,1,4], then you can apply one of the following operations to it (not all possible options are listed below):
* decrement from the first two elements of the array. After this operation a=[2, 1, 2, 1, 4];
* decrement from the last three elements of the array. After this operation a=[3, 2, 1, 0, 3];
* decrement from the first five elements of the array. After this operation a=[2, 1, 1, 0, 3];
Determine if it is possible to make all the elements of the array equal to zero by applying a certain number of operations.
Input
The first line contains one positive integer t (1 ≤ t ≤ 30000) — the number of test cases. Then t test cases follow.
Each test case begins with a line containing one integer n (1 ≤ n ≤ 30000) — the number of elements in the array.
The second line of each test case contains n integers a_1 … a_n (1 ≤ a_i ≤ 10^6).
The sum of n over all test cases does not exceed 30000.
Output
For each test case, output on a separate line:
* YES, if it is possible to make all elements of the array equal to zero by applying a certain number of operations.
* NO, otherwise.
The letters in the words YES and NO can be outputed in any case.
Example
Input
4
3
1 2 1
5
11 7 9 6 8
5
1 3 1 3 1
4
5 2 1 10
Output
YES
YES
NO
YES
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
const int oo = 1e9 + 7;
const ll mod = 1e9 + 7, maxn = 2e5 + 100, maxm = 1e5 + 100;
const double PI = acos(-1);
string solve() {
int n, c = 0;
cin >> n;
vector<int> mn(n, 0), vs(n);
for (int i = 0; i < n; i++) {
cin >> vs[i];
}
for (int i = 1; i < n; i++) {
vs[i] -= c;
if (vs[i] > vs[i - 1]) c += (vs[i] - vs[i - 1]), vs[i] = vs[i - 1];
if (vs[i] < 0) return "NO";
}
return "YES";
}
int main() {
ios_base::sync_with_stdio(false);
int tt;
cin >> tt;
while (tt--) {
cout << solve() << endl;
}
return 0;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
Find the sum of weights of edges of the Minimum Spanning Tree for a given weighted undirected graph G = (V, E).
Constraints
* 1 ≤ |V| ≤ 10,000
* 0 ≤ |E| ≤ 100,000
* 0 ≤ wi ≤ 10,000
* The graph is connected
* There are no parallel edges
* There are no self-loops
Input
|V| |E|
s0 t0 w0
s1 t1 w1
:
s|E|-1 t|E|-1 w|E|-1
, where |V| is the number of vertices and |E| is the number of edges in the graph. The graph vertices are named with the numbers 0, 1,..., |V|-1 respectively.
si and ti represent source and target verticess of i-th edge (undirected) and wi represents the weight of the i-th edge.
Output
Print the sum of the weights of the Minimum Spanning Tree.
Examples
Input
4 6
0 1 2
1 2 1
2 3 1
3 0 1
0 2 3
1 3 5
Output
3
Input
6 9
0 1 1
0 2 3
1 2 1
1 3 7
2 4 1
1 4 3
3 4 1
3 5 1
4 5 6
Output
5
### Response
```cpp
#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
const int maxn = 200000 + 5;
struct node {
int x;
int y;
int v;
}r[maxn];
int n,m;
int f[maxn];
bool cmp(node a,node b){
return a.v < b.v;
}
int find(int x){
if(f[x] == x)return x;
else return f[x] = find(f[x]);
}
int Kruskal(){
int ans = 0;
for(int i = 1;i <= n; i++)f[i] = i;
sort(r+1,r+m+1,cmp);
for(int i = 1;i <= m; i++){
int x = find(r[i].x),y = find(r[i].y);
if(x != y){
ans += r[i].v;
f[x] = y;
}
}
return ans;
}
int main(){
scanf("%d%d",&n,&m);
for(int i = 1;i <= m; i++)scanf("%d%d%d",&r[i].x,&r[i].y,&r[i].v);
int ans = Kruskal();
printf("%d\n",ans);
}
``` |
### Prompt
Create a solution in CPP for the following problem:
Description
KMC sells CDs every year at a coterie spot sale called Comic Market. F was supposed to sell CDs at the comic market, but due to the popularity of F, the KMC sales floor was flooded with people, and the calculation of change could not keep up. So F decided to write a program that would output the change as soon as he entered the amount.
KMC prepares only 100-yen coins, 500-yen coins, and 1000-yen coins as change. You can think of these coins and bills as infinite. Choose change so that the number of coins and bills is minimized. Also, the price of CDs sold by KMC is a multiple of 100, and the amount paid by the purchaser is also a multiple of 100.
Input
The input consists of multiple test cases.
Each test case consists of two positive integers A and B. A is the price of the CD and B is the amount paid by the purchaser. A and B are multiples of 100 and do not exceed 100000000. Also, A ≤ B.
The input ends with 0 0.
Output
For each test case, the number and number of 100-yen coins, 500-yen coins, and 1000-yen coins that should be presented as change are output in this order in one line. Insert a space between each number.
Example
Input
500 1000
100 10000
400 700
600 5000
10000 10000
0 0
Output
0 1 0
4 1 9
3 0 0
4 0 4
0 0 0
### Response
```cpp
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main(){
while(1){
int a,b;
cin >> a >> b;
if(a==0 && b==0) break;
int rem = b-a;
int ans[3] = {};
ans[2] = rem/1000;
rem %= 1000;
ans[1] = rem/500;
rem %= 500;
ans[0] = rem/100;
cout << ans[0] << " " << ans[1] << " " << ans[2] << endl;
}
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
In Republic of Atcoder, there are N prefectures, and a total of M cities that belong to those prefectures.
City i is established in year Y_i and belongs to Prefecture P_i.
You can assume that there are no multiple cities that are established in the same year.
It is decided to allocate a 12-digit ID number to each city.
If City i is the x-th established city among the cities that belong to Prefecture i, the first six digits of the ID number of City i is P_i, and the last six digits of the ID number is x.
Here, if P_i or x (or both) has less than six digits, zeros are added to the left until it has six digits.
Find the ID numbers for all the cities.
Note that there can be a prefecture with no cities.
Constraints
* 1 \leq N \leq 10^5
* 1 \leq M \leq 10^5
* 1 \leq P_i \leq N
* 1 \leq Y_i \leq 10^9
* Y_i are all different.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
P_1 Y_1
:
P_M Y_M
Output
Print the ID numbers for all the cities, in ascending order of indices (City 1, City 2, ...).
Examples
Input
2 3
1 32
2 63
1 12
Output
000001000002
000002000001
000001000001
Input
2 3
2 55
2 77
2 99
Output
000002000001
000002000002
000002000003
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<vector<int>> pref(N + 1);
vector<int> p(M);
vector<int> y(M);
for (int i = 0; i < M; ++i) {
cin >> p[i] >> y[i];
pref[p[i]].push_back(y[i]);
}
for (int i = 0; i < N + 1; ++i) {
sort(pref[i].begin(), pref[i].end());
}
for (int i = 0; i < M; ++i) {
int l = p[i];
int r = lower_bound(pref[p[i]].begin(), pref[p[i]].end(), y[i]) - pref[p[i]].begin() + 1;
printf("%06d%06d\n", l, r);
}
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
This is an interactive problem.
The judge has a hidden rooted full binary tree with n leaves. A full binary tree is one where every node has either 0 or 2 children. The nodes with 0 children are called the leaves of the tree. Since this is a full binary tree, there are exactly 2n - 1 nodes in the tree. The leaves of the judge's tree has labels from 1 to n. You would like to reconstruct a tree that is isomorphic to the judge's tree. To do this, you can ask some questions.
A question consists of printing the label of three distinct leaves a1, a2, a3. Let the depth of a node be the shortest distance from the node to the root of the tree. Let LCA(a, b) denote the node with maximum depth that is a common ancestor of the nodes a and b.
Consider X = LCA(a1, a2), Y = LCA(a2, a3), Z = LCA(a3, a1). The judge will tell you which one of X, Y, Z has the maximum depth. Note, this pair is uniquely determined since the tree is a binary tree; there can't be any ties.
More specifically, if X (or Y, Z respectively) maximizes the depth, the judge will respond with the string "X" (or "Y", "Z" respectively).
You may only ask at most 10·n questions.
Input
The first line of input will contain a single integer n (3 ≤ n ≤ 1 000) — the number of leaves in the tree.
Output
To print the final answer, print out the string "-1" on its own line. Then, the next line should contain 2n - 1 integers. The i-th integer should be the parent of the i-th node, or -1, if it is the root.
Your answer will be judged correct if your output is isomorphic to the judge's tree. In particular, the labels of the leaves do not need to be labeled from 1 to n. Here, isomorphic means that there exists a permutation π such that node i is the parent of node j in the judge tree if and only node π(i) is the parent of node π(j) in your tree.
Interaction
To ask a question, print out three distinct integers a1, a2, a3. These integers should be between 1 and n, inclusive.
The judge will respond with a single character, either "X", "Y", "Z".
If the string is "X" (or "Y", "Z" respectively), that means the pair (a1, a2) (or (a2, a3), (a3, a1) respectively) has the deepest LCA among the three pairs.
You may only ask a question at most 10·n times, otherwise, you will get Wrong Answer.
When you are ready to answer, print out a single integer "-1" on its own line. The next line should contain 2n - 1 integers. The i-th integer should be the parent of the i-th node, or -1, if it is the root. Do not forget to flush the final answer as well. Printing the answer does not count as asking a question.
You will get Wrong Answer verdict if
* Your question or answers are not in the format described in this statement.
* You ask strictly more than 10·n questions.
* Your question contains duplicate indices.
* Your final answer is not isomorphic to the judge tree.
You will get Idleness Limit Exceeded if you don't print anything or if you forget to flush the output, including for the final answer (more info about flushing output below).
To flush you can use (just after printing an integer and end-of-line):
* fflush(stdout) in C++;
* System.out.flush() in Java;
* stdout.flush() in Python;
* flush(output) in Pascal;
* See the documentation for other languages.
If at any moment your program reads -1 as an answer, it should immediately exit normally (for example, by calling exit(0)). You will get Wrong Answer in this case, it means that you made more queries than allowed, or made an invalid query. If you ignore this, you can get other verdicts since your program will continue to read from a closed stream.
Hacking To hack someone, use the following format
n
p_1 p_2 ... p_{2n-1}
This denotes a tree where the parent of the i-th node is pi (pi = - 1 or n < pi ≤ 2n - 1). If pi is equal to -1, then node i is the root. This input must describe a valid full rooted binary tree.
Of course, contestant programs will not be able to see this input.
Example
Input
5
X
Z
Y
Y
X<span class="tex-font-style-tt"></span>
Output
1 4 2
1 2 4
2 4 1
2 3 5
2 4 3
-1
-1 1 1 2 2 3 3 6 6
Note
For the first sample, the judge has the hidden tree:
<image>
Here is a more readable format of the interaction:
<image> The last line can also be 8 6 9 8 9 7 -1 6 7.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 1000 + 5;
int N, sz;
int leftSon[2 * NMAX];
int rightSon[2 * NMAX];
int father[2 * NMAX];
pair<int, int> queryPair[2 * NMAX];
string askDir(int node, int searched) {
cout << queryPair[node].first << ' ' << queryPair[node].second << ' '
<< searched << endl;
char ans;
cin >> ans;
if (ans == 'X')
return "UP";
else if (ans == 'Z')
return "LEFT";
else
return "RIGHT";
}
bool vis[2 * NMAX];
int szs[2 * NMAX];
void computeSzs(int node, int f) {
szs[node] = 1;
for (auto it : {leftSon[node], rightSon[node], father[node]})
if (it && it != f && !vis[it]) {
computeSzs(it, node);
szs[node] += szs[it];
}
}
int getCentroid(int node, int f, int atMost) {
for (auto it : {leftSon[node], rightSon[node], father[node]})
if (it && it != f && !vis[it] && szs[it] > atMost)
return getCentroid(it, node, atMost);
if (node <= N) {
for (auto it : {leftSon[node], rightSon[node], father[node]})
if (it && it != f && !vis[it]) return getCentroid(it, node, atMost);
return -1;
} else
return node;
}
void insertOnEdge(int node, int searched) {
if (father[node] == 0) {
++sz;
leftSon[sz] = node;
father[node] = sz;
rightSon[sz] = searched;
queryPair[sz] = {queryPair[node].first, searched};
father[searched] = sz;
} else if (node == leftSon[father[node]]) {
node = father[node];
++sz;
leftSon[sz] = leftSon[node];
father[leftSon[node]] = sz;
leftSon[node] = sz;
father[sz] = node;
rightSon[sz] = searched;
queryPair[sz] = {queryPair[leftSon[sz]].first, searched};
father[searched] = sz;
} else {
node = father[node];
++sz;
rightSon[sz] = rightSon[node];
father[rightSon[node]] = sz;
rightSon[node] = sz;
father[sz] = node;
leftSon[sz] = searched;
queryPair[sz] = {searched, queryPair[rightSon[sz]].second};
father[searched] = sz;
}
}
void findAndUpdate(int node, int searched) {
computeSzs(node, 0);
int cent = getCentroid(node, 0, szs[node] / 2);
if (cent == -1) {
insertOnEdge(node, searched);
return;
}
node = cent;
vis[node] = true;
string ask = askDir(node, searched);
if (ask == "UP") {
if (!vis[father[node]] && father[node])
findAndUpdate(father[node], searched);
else
insertOnEdge(node, searched);
} else if (ask == "LEFT") {
if (!vis[leftSon[node]])
findAndUpdate(leftSon[node], searched);
else
insertOnEdge(leftSon[node], searched);
} else {
if (!vis[rightSon[node]])
findAndUpdate(rightSon[node], searched);
else
insertOnEdge(rightSon[node], searched);
}
}
int main() {
cin >> N;
sz = N + 1;
leftSon[sz] = 1;
rightSon[sz] = 2;
father[1] = father[2] = sz;
queryPair[sz] = {1, 2};
for (int i = 1; i <= N; ++i) queryPair[i] = {i, i};
for (int i = 3; i <= N; ++i) {
memset(vis, 0, sizeof vis);
findAndUpdate(sz, i);
}
cout << "-1" << endl;
for (int i = 1; i <= sz; ++i)
if (father[i] == 0) father[i] = -1;
for (int i = 1; i <= sz; ++i) cout << father[i] << " \n"[i == sz];
cout.flush();
return 0;
}
``` |
Subsets and Splits