text
stringlengths 424
69.5k
|
|---|
### Prompt
Your task is to create a Cpp solution to the following problem:
You're a mikemon breeder currently in the middle of your journey to become a mikemon master. Your current obstacle is go through the infamous Biridian Forest.
The forest
The Biridian Forest is a two-dimensional grid consisting of r rows and c columns. Each cell in Biridian Forest may contain a tree, or may be vacant. A vacant cell may be occupied by zero or more mikemon breeders (there may also be breeders other than you in the forest). Mikemon breeders (including you) cannot enter cells with trees. One of the cells is designated as the exit cell.
The initial grid, including your initial position, the exit cell, and the initial positions of all other breeders, will be given to you. Here's an example of such grid (from the first example):
<image>
Moves
Breeders (including you) may move in the forest. In a single move, breeders may perform one of the following actions:
* Do nothing.
* Move from the current cell to one of the four adjacent cells (two cells are adjacent if they share a side). Note that breeders cannot enter cells with trees.
* If you are located on the exit cell, you may leave the forest. Only you can perform this move — all other mikemon breeders will never leave the forest by using this type of movement.
After each time you make a single move, each of the other breeders simultaneously make a single move (the choice of which move to make may be different for each of the breeders).
Mikemon battle
If you and t (t > 0) mikemon breeders are located on the same cell, exactly t mikemon battles will ensue that time (since you will be battling each of those t breeders once). After the battle, all of those t breeders will leave the forest to heal their respective mikemons.
Note that the moment you leave the forest, no more mikemon battles can ensue, even if another mikemon breeder move to the exit cell immediately after that. Also note that a battle only happens between you and another breeders — there will be no battle between two other breeders (there may be multiple breeders coexisting in a single cell).
Your goal
You would like to leave the forest. In order to do so, you have to make a sequence of moves, ending with a move of the final type. Before you make any move, however, you post this sequence on your personal virtual idol Blog. Then, you will follow this sequence of moves faithfully.
Goal of other breeders
Because you post the sequence in your Blog, the other breeders will all know your exact sequence of moves even before you make your first move. All of them will move in such way that will guarantee a mikemon battle with you, if possible. The breeders that couldn't battle you will do nothing.
Your task
Print the minimum number of mikemon battles that you must participate in, assuming that you pick the sequence of moves that minimize this number. Note that you are not required to minimize the number of moves you make.
Input
The first line consists of two integers: r and c (1 ≤ r, c ≤ 1000), denoting the number of rows and the number of columns in Biridian Forest. The next r rows will each depict a row of the map, where each character represents the content of a single cell:
* 'T': A cell occupied by a tree.
* 'S': An empty cell, and your starting position. There will be exactly one occurence of this in the map.
* 'E': An empty cell, and where the exit is located. There will be exactly one occurence of this in the map.
* A digit (0-9): A cell represented by a digit X means that the cell is empty and is occupied by X breeders (in particular, if X is zero, it means that the cell is not occupied by any breeder).
It is guaranteed that it will be possible for you to go from your starting position to the exit cell through a sequence of moves.
Output
A single line denoted the minimum possible number of mikemon battles that you have to participate in if you pick a strategy that minimize this number.
Examples
Input
5 7
000E0T3
T0TT0T0
010T0T0
2T0T0T0
0T0S000
Output
3
Input
1 4
SE23
Output
2
Note
The following picture illustrates the first example. The blue line denotes a possible sequence of moves that you should post in your blog:
<image>
The three breeders on the left side of the map will be able to battle you — the lone breeder can simply stay in his place until you come while the other two breeders can move to where the lone breeder is and stay there until you come. The three breeders on the right does not have a way to battle you, so they will stay in their place.
For the second example, you should post this sequence in your Blog:
<image>
Here's what happens. First, you move one cell to the right.
<image>
Then, the two breeders directly to the right of the exit will simultaneously move to the left. The other three breeder cannot battle you so they will do nothing.
<image>
You end up in the same cell with 2 breeders, so 2 mikemon battles are conducted. After those battles, all of your opponents leave the forest.
<image>
Finally, you make another move by leaving the forest.
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
char g[1100][1100];
int dist[1100][1100];
int n, m;
int ax[] = {-1, 1, 0, 0}, by[] = {0, 0, -1, 1};
bool check(int x, int y) { return x >= 0 && x < n && y >= 0 && y < m; }
void bfs(int x, int y) {
queue<int> qu;
qu.push(x);
qu.push(y);
dist[x][y] = 0;
while (!qu.empty()) {
int stx = qu.front();
qu.pop();
int sty = qu.front();
qu.pop();
for (int i = 0; i < 4; i++) {
int tx = stx + ax[i], ty = sty + by[i];
if (check(tx, ty) && g[tx][ty] != 'T') {
if (dist[tx][ty] > dist[stx][sty] + 1) {
dist[tx][ty] = dist[stx][sty] + 1;
qu.push(tx);
qu.push(ty);
}
}
}
}
}
int main() {
while (scanf(" %d %d", &n, &m) == 2) {
for (int i = 0; i < n; i++) scanf(" %s", g[i]);
memset(dist, 0x3f, sizeof(dist));
int x, y;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (g[i][j] == 'E') {
bfs(i, j);
}
if (g[i][j] == 'S') {
x = i;
y = j;
}
}
}
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (dist[x][y] >= dist[i][j] && isdigit(g[i][j])) {
ans += g[i][j] - '0';
}
}
}
printf("%d\n", ans);
fflush(stdout);
}
return 0;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
Polycarp is a regular customer at the restaurant "Ber Patio". He likes having lunches there.
"Ber Patio" has special discount program for regular customers. A customer can collect bonuses and partially cover expenses in the restaurant.
Let's assume a customer currently has b bonuses and she has to pay r burles for a lunch. In this case the customer can use bonuses (1 bonus = 1 burle) to reduce the payment. She can cover at most half of the payment using bonuses. However, 1 bonus will be added to the customer's bonus balance per each 10 burles she paid.
Formally:
1. a customer can choose any number x of bonuses to use (<image>)),
2. the customer's bonus balance is reduced by x,
3. the customer pays r - x burles,
4. the customer's bonus balance is increased by ⌊(r - x) / 10⌋ (i.e. integer division rounded down is used).
Initially, there are b bonuses on Polycarp's account. Polycarp is going to have a lunch in "Ber Patio" for the next n days. He estimated the values a1, a2, ..., an, where ai is the number of burles in a receipt for the i-th day. The sum over all receipts doesn't exceed 105 burles.
Write a program to find the minimum number of burles Polycarp has to spend and an optimal strategy to use bonuses.
Input
The first line contains two integer numbers n and b (1 ≤ n ≤ 5000, 0 ≤ b ≤ 105) — number of days and initial number of bonuses Polycarp has.
The second line contains the integer sequence a1, a2, ..., an (1 ≤ ai ≤ 1000), where ai is the amount of burles in the i-th day's receipt.
It is guaranteed that the sum of all receipts does not exceed 105 burles.
Output
On the first line, print the expected minimal number of burles to pay for all n receipts.
On the second line, print the sequence of integer numbers b1, b2, ..., bn, where bi is the number of bonuses to use on the i-th day. If there are multiple solutions, print any of them.
Examples
Input
3 21
12 75 52
Output
110
2 5 22
Input
3 39
58 64 33
Output
107
28 4 16
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 10005;
int dp[2][maxn];
int a[maxn];
const int inf = 1000000000;
int pre[5006][maxn];
int con[maxn];
int main() {
int n, b;
int u = 0;
cin >> n >> b;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 0; i < (maxn); i++) dp[0][i] = dp[1][i] = inf;
dp[0][0] = 0;
int all = 0;
for (int i = 1; i <= n; i++) {
u = u ^ 1;
for (int j = 0; j < maxn; j++) {
if (dp[u ^ 1][j] != inf) {
int rest = -(all - dp[u ^ 1][j]) + b + j;
for (int f = 0; f <= min(rest, a[i] / 2); f++) {
if (dp[u][j + (a[i] - f) / 10] > dp[u ^ 1][j] + a[i] - f) {
dp[u][j + (a[i] - f) / 10] = dp[u ^ 1][j] + a[i] - f;
pre[i][j + (a[i] - f) / 10] = f;
}
}
}
}
for (int j = 0; j < maxn; j++) {
dp[u ^ 1][j] = inf;
}
all += a[i];
}
int ans = inf;
int rest = 0;
for (int i = 0; i < maxn; i++) {
if (ans > dp[u][i]) {
ans = dp[u][i];
rest = i;
}
}
printf("%d\n", ans);
for (int i = n; i >= 1; i--) {
con[i] = pre[i][rest];
rest = rest - (a[i] - pre[i][rest]) / 10;
}
for (int i = 1; i <= n; i++) printf("%d ", con[i]);
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
Polycarp is an organizer of a Berland ICPC regional event. There are n universities in Berland numbered from 1 to n. Polycarp knows all competitive programmers in the region. There are n students: the i-th student is enrolled at a university u_i and has a programming skill s_i.
Polycarp has to decide on the rules now. In particular, the number of members in the team.
Polycarp knows that if he chooses the size of the team to be some integer k, each university will send their k strongest (with the highest programming skill s) students in the first team, the next k strongest students in the second team and so on. If there are fewer than k students left, then the team can't be formed. Note that there might be universities that send zero teams.
The strength of the region is the total skill of the members of all present teams. If there are no teams present, then the strength is 0.
Help Polycarp to find the strength of the region for each choice of k from 1 to n.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of testcases.
The first line of each testcase contains a single integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of universities and the number of students.
The second line of each testcase contains n integers u_1, u_2, ..., u_n (1 ≤ u_i ≤ n) — the university the i-th student is enrolled at.
The third line of each testcase contains n integers s_1, s_2, ..., s_n (1 ≤ s_i ≤ 10^9) — the programming skill of the i-th student.
The sum of n over all testcases doesn't exceed 2 ⋅ 10^5.
Output
For each testcase print n integers: the strength of the region — the total skill of the members of the present teams — for each choice of team size k.
Example
Input
4
7
1 2 1 2 1 2 1
6 8 3 1 5 1 5
10
1 1 1 2 2 2 2 3 3 3
3435 3014 2241 2233 2893 2102 2286 2175 1961 2567
6
3 3 3 3 3 3
5 9 6 7 9 7
1
1
3083
Output
29 28 26 19 0 0 0
24907 20705 22805 9514 0 0 0 0 0 0
43 43 43 32 38 43
3083
Note
In the first testcase the teams from each university for each k are:
* k=1:
* university 1: [6], [5], [5], [3];
* university 2: [8], [1], [1];
* k=2:
* university 1: [6, 5], [5, 3];
* university 2: [8, 1];
* k=3:
* university 1: [6, 5, 5];
* university 2: [8, 1, 1];
* k=4:
* university 1: [6, 5, 5, 3];
### Response
```cpp
#include<bits/stdc++.h>
#define optimize() ios_base::sync_with_stdio(0);
#define ll long long
using namespace std;
int main()
{
int t;cin>>t;
while(t--)
{
ll n,i,j,k=1,x,y,m,sum;
ll a[210000],b[210000],c;
map<ll,ll>mp1;
cin>>n;
vector<ll>v[n+3];
vector<ll>v1[n+3];
map<pair<int,int>,ll>mp;
pair<int,int>p;
for(i=1;i<=n;i++){
cin>>a[i];
if(mp1[a[i]]==0){
b[k]=a[i];k++;
}
mp1[a[i]]=1;
}
for(i=1;i<=n;i++){
cin>>c;
v[a[i]].push_back(c);
a[i]=0;
}
sort(b+1,b+k);
for(i=1;i<k;i++){
x=b[i];sum=0;
sort(v[x].rbegin(),v[x].rend());
for(j=0;j<v[x].size();j++){
sum+=v[x][j];
// cout<<sum<<" ";
p=make_pair(x,j+1);
mp[p]=sum;
v1[j+1].push_back(x);
}
}
for(i=1;i<=n;i++){
sum=0;
for(auto u:v1[i]){
y=v[u].size()/i;
y=y*i;
// cout<<y<<" ";
p=make_pair(u,y);
sum+=mp[p];
}
cout<<sum<<" ";
}
cout<<endl;
}
return 0;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
A duck hunter is doing his favorite thing, hunting. He lives in a two dimensional world and is located at point (0, 0). As he doesn't like walking for his prey, he prefers to shoot only vertically up (because in this case, the ducks fall straight into his hands). The hunter doesn't reload the gun immediately — r or more seconds must pass between the shots. When the hunter shoots up, the bullet immediately hits all the ducks who are directly above the hunter.
In a two dimensional world each duck is a horizontal segment that moves horizontally in the negative direction of the Ox axis at the speed 1 length unit per second. For each duck we know the values hi and ti — the x-coordinates of its head (the left end of the segment) and its tail (the right end of the segment) at time 0. The height where the duck is flying isn't important as the gun shoots vertically up to the infinite height and hits all the ducks on its way.
<image> The figure to the first sample.
What maximum number of ducks can the hunter shoot? The duck is considered shot by the hunter if at the moment of the shot at least one of its point intersects the Oy axis. After the hunter shoots the duck, it falls and it can't be shot anymore. The hunter cannot make shots before the moment of time 0.
Input
The first line of the input contains integers n, r (1 ≤ n ≤ 200 000, 1 ≤ r ≤ 109) — the number of ducks and the minimum time in seconds between the shots.
Then n lines follow, each of them contains two integers hi, ti ( - 109 ≤ hi < ti ≤ 109) — the x-coordinate of the head and tail of the i-th duck at the moment 0.
Output
Print a single integer — the maximum number of ducks that can be shot by the hunter.
Examples
Input
3 3
-3 0
1 3
-1 2
Output
3
Input
4 5
-1 1
2 4
5 9
6 8
Output
3
Note
In the first sample the hunter must shoot at time 0, this shot kills ducks 1 and 3. Then the hunter needs to reload the gun and shoot again at time 3. His second shot hits the tail of duck 2.
In the second sample the hunter can make shots at times 0 and 6 to hit three ducks.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, d;
struct Node {
int mx, ad;
} seg[200010 * 12];
pair<int, int> inp[200010];
map<int, int> dis;
int inv[200010 * 4];
int cn = 0;
int cmi = 0;
int lav = -1;
int cl = 0;
void assignV(int ed) {
typeof(dis.begin()) it = dis.upper_bound(lav);
for (; it != dis.end() && it->first <= ed; ++it) {
inv[cn] = it->first;
it->second = cn++;
}
lav = ed;
}
void s_add(int i, int l, int r, int st, int ed, int av) {
if (ed <= st) return;
if (st == l && ed == r) {
seg[i].mx += av;
seg[i].ad += av;
return;
}
int m = (l + r) / 2;
if (m <= st)
s_add(i * 2 + 2, m, r, st, ed, av);
else if (m >= ed)
s_add(i * 2 + 1, l, m, st, ed, av);
else {
s_add(i * 2 + 1, l, m, st, m, av);
s_add(i * 2 + 2, m, r, m, ed, av);
}
seg[i].mx = max(seg[2 * i + 1].mx, seg[2 * i + 2].mx) + seg[i].ad;
}
int s_getMinId(int i, int l, int r, int av, int cv) {
if (seg[i].mx + av < cv) return r;
if (l + 1 == r) return l;
int m = (l + r) / 2;
if (seg[2 * i + 1].mx + av + seg[i].ad >= cv)
return s_getMinId(i * 2 + 1, l, m, av + seg[i].ad, cv);
else
return s_getMinId(i * 2 + 2, m, r, av + seg[i].ad, cv);
}
void lemon() {
scanf("%d%d", &n, &d);
for (int i = (0); i <= (n - 1); i++) {
int s, t;
scanf("%d%d", &s, &t);
if (t < 0)
i--, n--;
else {
s = max(s, 0);
inp[i] = pair<int, int>(t + 1, s);
dis[s] = 0, dis[t + 1] = 0;
}
}
sort(inp, inp + n);
int maxd = n * 3 + 1;
inv[maxd] = 1000000001;
for (int i = (0); i <= (n - 1); i++) {
int np = inv[s_getMinId(0, 0, maxd, 0, cmi + 1)];
np += d;
if (np < cl) np = cl;
if (np <= inp[i].first) {
cmi++;
if (dis.find(np) == dis.end()) dis[np] = 0;
assignV(np);
s_add(0, 0, maxd, dis[np], maxd, 1);
cl = np;
i--;
} else {
assignV(inp[i].first);
s_add(0, 0, maxd, dis[inp[i].second], dis[inp[i].first], 1);
cl = inp[i].first;
}
}
printf("%d\n", seg[0].mx);
}
int main() {
ios::sync_with_stdio(true);
lemon();
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Mikhail walks on a Cartesian plane. He starts at the point (0, 0), and in one move he can go to any of eight adjacent points. For example, if Mikhail is currently at the point (0, 0), he can go to any of the following points in one move:
* (1, 0);
* (1, 1);
* (0, 1);
* (-1, 1);
* (-1, 0);
* (-1, -1);
* (0, -1);
* (1, -1).
If Mikhail goes from the point (x1, y1) to the point (x2, y2) in one move, and x1 ≠ x2 and y1 ≠ y2, then such a move is called a diagonal move.
Mikhail has q queries. For the i-th query Mikhail's target is to go to the point (n_i, m_i) from the point (0, 0) in exactly k_i moves. Among all possible movements he want to choose one with the maximum number of diagonal moves. Your task is to find the maximum number of diagonal moves or find that it is impossible to go from the point (0, 0) to the point (n_i, m_i) in k_i moves.
Note that Mikhail can visit any point any number of times (even the destination point!).
Input
The first line of the input contains one integer q (1 ≤ q ≤ 10^4) — the number of queries.
Then q lines follow. The i-th of these q lines contains three integers n_i, m_i and k_i (1 ≤ n_i, m_i, k_i ≤ 10^{18}) — x-coordinate of the destination point of the query, y-coordinate of the destination point of the query and the number of moves in the query, correspondingly.
Output
Print q integers. The i-th integer should be equal to -1 if Mikhail cannot go from the point (0, 0) to the point (n_i, m_i) in exactly k_i moves described above. Otherwise the i-th integer should be equal to the the maximum number of diagonal moves among all possible movements.
Example
Input
3
2 2 3
4 3 7
10 1 9
Output
1
6
-1
Note
One of the possible answers to the first test case: (0, 0) → (1, 0) → (1, 1) → (2, 2).
One of the possible answers to the second test case: (0, 0) → (0, 1) → (1, 2) → (0, 3) → (1, 4) → (2, 3) → (3, 2) → (4, 3).
In the third test case Mikhail cannot reach the point (10, 1) in 9 moves.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
bool sortmd(pair<pair<int, int>, int> &a, pair<pair<int, int>, int> &b) {
if (a.first.first == b.first.first) return a.first.second < b.first.second;
return a.first.first > b.first.first;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
srand(time(NULL));
int t = 1;
cin >> t;
while (t--) {
long long x, y, k, i, j;
cin >> x >> y >> k;
if (x < y) swap(x, y);
if (k < x)
cout << -1 << endl;
else
cout << ((x + y) % 2 ? k - 1 : (k - x) % 2 ? k - 2 : k) << endl;
}
return 0;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
Sereja painted n points on the plane, point number i (1 ≤ i ≤ n) has coordinates (i, 0). Then Sereja marked each point with a small or large English letter. Sereja don't like letter "x", so he didn't use it to mark points. Sereja thinks that the points are marked beautifully if the following conditions holds:
* all points can be divided into pairs so that each point will belong to exactly one pair;
* in each pair the point with the lesser abscissa will be marked with a small English letter and the point with the larger abscissa will be marked with the same large English letter;
* if we built a square on each pair, the pair's points will be the square's opposite points and the segment between them will be the square's diagonal, then among the resulting squares there won't be any intersecting or touching ones.
Little Petya erased some small and all large letters marking the points. Now Sereja wonders how many ways are there to return the removed letters so that the points were marked beautifully.
Input
The first line contains integer n the number of points (1 ≤ n ≤ 105). The second line contains a sequence consisting of n small English letters and question marks — the sequence of letters, that mark points, in order of increasing x-coordinate of points. Question marks denote the points without letters (Petya erased them). It is guaranteed that the input string doesn't contain letter "x".
Output
In a single line print the answer to the problem modulo 4294967296. If there is no way to return the removed letters, print number 0.
Please, do not write the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
4
a???
Output
50
Input
4
abc?
Output
0
Input
6
abc???
Output
1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
inline bool isLower(char c) { return c >= 'a' && c <= 'z'; }
inline bool isUpper(char c) { return c >= 'A' && c <= 'Z'; }
int n, cnt;
char s[100005];
unsigned int dpa[2][50005];
unsigned int fpow(unsigned int x, int y) {
if (y == 0) return 1;
unsigned int res = fpow(x, y / 2);
return y % 2 == 1 ? res * res * x : res * res;
}
int main() {
scanf("%d %s", &n, s);
dpa[1][0] = 1;
for (int i = 0; i < n; i++) cnt += s[i] != '?';
if (cnt > n / 2) {
printf("%d\n", 0);
return 0;
}
for (int i = 0; i < n; i++) {
int p = i & 1;
int mx = min(i + 1, n - i - 1);
if (s[i] == '?') {
dpa[p][0] = dpa[p ^ 1][1];
for (int j = 1; j <= mx; j++) {
dpa[p][j + 0] = dpa[p ^ 1][j - 1 + 0] + dpa[p ^ 1][j + 1 + 0];
}
} else {
dpa[p][0] = 0;
for (int j = 1; j <= mx; j++) {
dpa[p][j + 0] = dpa[p ^ 1][j - 1 + 0];
}
}
}
printf("%u\n", dpa[(n - 1) & 1][0] * fpow(25, n / 2 - cnt));
return 0;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
Vova is again playing some computer game, now an RPG. In the game Vova's character received a quest: to slay the fearsome monster called Modcrab.
After two hours of playing the game Vova has tracked the monster and analyzed its tactics. The Modcrab has h2 health points and an attack power of a2. Knowing that, Vova has decided to buy a lot of strong healing potions and to prepare for battle.
Vova's character has h1 health points and an attack power of a1. Also he has a large supply of healing potions, each of which increases his current amount of health points by c1 when Vova drinks a potion. All potions are identical to each other. It is guaranteed that c1 > a2.
The battle consists of multiple phases. In the beginning of each phase, Vova can either attack the monster (thus reducing its health by a1) or drink a healing potion (it increases Vova's health by c1; Vova's health can exceed h1). Then, if the battle is not over yet, the Modcrab attacks Vova, reducing his health by a2. The battle ends when Vova's (or Modcrab's) health drops to 0 or lower. It is possible that the battle ends in a middle of a phase after Vova's attack.
Of course, Vova wants to win the fight. But also he wants to do it as fast as possible. So he wants to make up a strategy that will allow him to win the fight after the minimum possible number of phases.
Help Vova to make up a strategy! You may assume that Vova never runs out of healing potions, and that he can always win.
Input
The first line contains three integers h1, a1, c1 (1 ≤ h1, a1 ≤ 100, 2 ≤ c1 ≤ 100) — Vova's health, Vova's attack power and the healing power of a potion.
The second line contains two integers h2, a2 (1 ≤ h2 ≤ 100, 1 ≤ a2 < c1) — the Modcrab's health and his attack power.
Output
In the first line print one integer n denoting the minimum number of phases required to win the battle.
Then print n lines. i-th line must be equal to HEAL if Vova drinks a potion in i-th phase, or STRIKE if he attacks the Modcrab.
The strategy must be valid: Vova's character must not be defeated before slaying the Modcrab, and the monster's health must be 0 or lower after Vova's last action.
If there are multiple optimal solutions, print any of them.
Examples
Input
10 6 100
17 5
Output
4
STRIKE
HEAL
STRIKE
STRIKE
Input
11 6 100
12 5
Output
2
STRIKE
STRIKE
Note
In the first example Vova's character must heal before or after his first attack. Otherwise his health will drop to zero in 2 phases while he needs 3 strikes to win.
In the second example no healing needed, two strikes are enough to get monster to zero health and win with 6 health left.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
queue<int> q;
int main() {
int h1, a1, c1, h2, a2;
cin >> h1 >> a1 >> c1;
cin >> h2 >> a2;
int cnt = 0;
while (h2 > 0) {
cnt++;
if (h1 > a2 || h2 <= a1) {
h2 -= a1;
h1 -= a2;
q.push(1);
} else {
h1 += c1;
h1 -= a2;
q.push(2);
}
}
cout << cnt << endl;
while (!q.empty()) {
int x = q.front();
q.pop();
if (x == 1)
cout << "STRIKE" << endl;
else
cout << "HEAL" << endl;
}
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
We often have to copy large volumes of information. Such operation can take up many computer resources. Therefore, in this problem you are advised to come up with a way to copy some part of a number array into another one, quickly.
More formally, you've got two arrays of integers a1, a2, ..., an and b1, b2, ..., bn of length n. Also, you've got m queries of two types:
1. Copy the subsegment of array a of length k, starting from position x, into array b, starting from position y, that is, execute by + q = ax + q for all integer q (0 ≤ q < k). The given operation is correct — both subsegments do not touch unexistent elements.
2. Determine the value in position x of array b, that is, find value bx.
For each query of the second type print the result — the value of the corresponding element of array b.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 105) — the number of elements in the arrays and the number of queries, correspondingly. The second line contains an array of integers a1, a2, ..., an (|ai| ≤ 109). The third line contains an array of integers b1, b2, ..., bn (|bi| ≤ 109).
Next m lines contain the descriptions of the queries. The i-th line first contains integer ti — the type of the i-th query (1 ≤ ti ≤ 2). If ti = 1, then the i-th query means the copying operation. If ti = 2, then the i-th query means taking the value in array b. If ti = 1, then the query type is followed by three integers xi, yi, ki (1 ≤ xi, yi, ki ≤ n) — the parameters of the copying query. If ti = 2, then the query type is followed by integer xi (1 ≤ xi ≤ n) — the position in array b.
All numbers in the lines are separated with single spaces. It is guaranteed that all the queries are correct, that is, the copying borders fit into the borders of arrays a and b.
Output
For each second type query print the result on a single line.
Examples
Input
5 10
1 2 0 -1 3
3 1 5 -2 0
2 5
1 3 3 3
2 5
2 4
2 1
1 2 1 4
2 1
2 4
1 4 2 1
2 2
Output
0
3
-1
3
2
3
-1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m, typ;
int a[100005], b[100005];
struct query {
int ain;
int bin;
int len;
};
int tree[400000];
int flag[400000];
inline void propagate(int n, int ts, int te) {
if (flag[n]) {
tree[n] = flag[n];
if (ts != te) {
flag[2 * n] = flag[n];
flag[2 * n + 1] = flag[n];
}
flag[n] = 0;
}
}
void update(int n, int ts, int te, int qs, int qe, int qno) {
propagate(n, ts, te);
if (te < qs || qe < ts)
return;
else if (qs <= ts && qe >= te) {
tree[n] = qno;
if (ts != te) {
flag[2 * n] = qno;
flag[2 * n + 1] = qno;
}
return;
}
update(2 * n, ts, (ts + te) / 2, qs, qe, qno);
update(2 * n + 1, (ts + te) / 2 + 1, te, qs, qe, qno);
tree[n] = qno;
}
int query(int n, int ts, int te, int nq) {
propagate(n, ts, te);
if ((ts == te) && (ts == nq))
return tree[n];
else if (nq > te || nq < ts)
return -1;
int lq = query(2 * n, ts, (ts + te) / 2, nq);
int rq = query(2 * n + 1, (ts + te) / 2 + 1, te, nq);
if (lq == -1) return rq;
return lq;
}
int main() {
scanf("%d%d", &n, &m);
int ain, bin, len;
struct query queries[100005];
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 1; i <= n; i++) {
scanf("%d", &b[i]);
}
for (int i = 1; i <= m; i++) {
scanf("%d", &typ);
if (typ == 1) {
scanf("%d%d%d", &queries[i].ain, &queries[i].bin, &queries[i].len);
update(1, 1, n, queries[i].bin, queries[i].bin + queries[i].len - 1, i);
} else {
int nq;
scanf("%d", &nq);
int qno = query(1, 1, n, nq);
if (!qno)
printf("%d\n", b[nq]);
else {
printf("%d\n", a[nq - queries[qno].bin + queries[qno].ain]);
}
}
}
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
A PIN code is a string that consists of exactly 4 digits. Examples of possible PIN codes: 7013, 0000 and 0990. Please note that the PIN code can begin with any digit, even with 0.
Polycarp has n (2 ≤ n ≤ 10) bank cards, the PIN code of the i-th card is p_i.
Polycarp has recently read a recommendation that it is better to set different PIN codes on different cards. Thus he wants to change the minimal number of digits in the PIN codes of his cards so that all n codes would become different.
Formally, in one step, Polycarp picks i-th card (1 ≤ i ≤ n), then in its PIN code p_i selects one position (from 1 to 4), and changes the digit in this position to any other. He needs to change the minimum number of digits so that all PIN codes become different.
Polycarp quickly solved this problem. Can you solve it?
Input
The first line contains integer t (1 ≤ t ≤ 100) — the number of test cases in the input. Then test cases follow.
The first line of each of t test sets contains a single integer n (2 ≤ n ≤ 10) — the number of Polycarp's bank cards. The next n lines contain the PIN codes p_1, p_2, ..., p_n — one per line. The length of each of them is 4. All PIN codes consist of digits only.
Output
Print the answers to t test sets. The answer to each set should consist of a n + 1 lines
In the first line print k — the least number of changes to make all PIN codes different. In the next n lines output the changed PIN codes in the order corresponding to their appearance in the input. If there are several optimal answers, print any of them.
Example
Input
3
2
1234
0600
2
1337
1337
4
3139
3139
3139
3139
Output
0
1234
0600
1
1337
1237
3
3139
3138
3939
6139
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long int t, n, i, x, k, cur, ar[10005], sayi[11];
bool vis[10005], vus[10005], vas[10005];
void coutt(int x) {
if (x / 1000)
cout << x << endl;
else if (x / 100)
cout << 0 << x << endl;
else if (x / 10)
cout << 0 << 0 << x << endl;
else
cout << 0 << 0 << 0 << x << endl;
}
void solve() {
for (i = 0; i < 10005; i++) {
k = vis[i] = vus[i] = ar[i] = vas[i] = 0;
}
cin >> n;
for (i = 0; i < n; i++) {
cin >> sayi[i];
ar[sayi[i]]++;
vus[sayi[i]] = 1;
vis[sayi[i]] = 1;
}
for (i = 0; i < 10005; i++) {
if (ar[i]) k += ar[i] - 1;
}
cout << k << endl;
for (i = 0; i < 10005; i++) {
while (ar[i] > 1) {
ar[i]--;
cur = i - i % 10;
while (vis[cur] or vus[cur]) cur++;
vis[cur] = 1;
}
}
for (i = 0; i < n; i++) {
cur = sayi[i];
if (vus[cur] and !vas[cur]) {
coutt(cur);
vas[cur] = 1;
continue;
}
cur -= cur % 10;
while ((!vis[cur] or vus[cur]) or vas[cur]) cur++;
vas[cur] = 1;
coutt(cur);
}
}
int main() {
cin >> t;
while (t--) solve();
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
Polycarp has n different binary words. A word called binary if it contains only characters '0' and '1'. For example, these words are binary: "0001", "11", "0" and "0011100".
Polycarp wants to offer his set of n binary words to play a game "words". In this game, players name words and each next word (starting from the second) must start with the last character of the previous word. The first word can be any. For example, these sequence of words can be named during the game: "0101", "1", "10", "00", "00001".
Word reversal is the operation of reversing the order of the characters. For example, the word "0111" after the reversal becomes "1110", the word "11010" after the reversal becomes "01011".
Probably, Polycarp has such a set of words that there is no way to put them in the order correspondent to the game rules. In this situation, he wants to reverse some words from his set so that:
* the final set of n words still contains different words (i.e. all words are unique);
* there is a way to put all words of the final set of words in the order so that the final sequence of n words is consistent with the game rules.
Polycarp wants to reverse minimal number of words. Please, help him.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases in the input. Then t test cases follow.
The first line of a test case contains one integer n (1 ≤ n ≤ 2⋅10^5) — the number of words in the Polycarp's set. Next n lines contain these words. All of n words aren't empty and contains only characters '0' and '1'. The sum of word lengths doesn't exceed 4⋅10^6. All words are different.
Guaranteed, that the sum of n for all test cases in the input doesn't exceed 2⋅10^5. Also, guaranteed that the sum of word lengths for all test cases in the input doesn't exceed 4⋅10^6.
Output
Print answer for all of t test cases in the order they appear.
If there is no answer for the test case, print -1. Otherwise, the first line of the output should contain k (0 ≤ k ≤ n) — the minimal number of words in the set which should be reversed. The second line of the output should contain k distinct integers — the indexes of the words in the set which should be reversed. Words are numerated from 1 to n in the order they appear. If k=0 you can skip this line (or you can print an empty line). If there are many answers you can print any of them.
Example
Input
4
4
0001
1000
0011
0111
3
010
101
0
2
00000
00001
4
01
001
0001
00001
Output
1
3
-1
0
2
1 2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
vector<int> vv[5];
map<string, int> aaa;
int vis[maxn], ans[maxn];
void add(string s, int len, int id) {
if (s[0] == '0' && s[len - 1] == '0') vv[0].push_back(id);
if (s[0] == '0' && s[len - 1] == '1') vv[1].push_back(id);
if (s[0] == '1' && s[len - 1] == '0') vv[2].push_back(id);
if (s[0] == '1' && s[len - 1] == '1') vv[3].push_back(id);
}
int solve() {
int n;
cin >> n;
for (int i = 1; i < n + 1; ++i) vis[i] = 0;
aaa.clear();
memset(vv, 0, sizeof(vv));
for (int i = 1; i < n + 1; ++i) {
string s;
cin >> s;
int len = s.length();
add(s, len, i);
aaa[s] = i;
reverse(s.begin(), s.end());
if (aaa.count(s))
vis[aaa[s]] = 1, vis[i] = 1;
else
vis[i] = 0;
}
int sz[5];
memset(sz, 0, sizeof(sz));
for (int i = 0; i < 4; ++i) sz[i] = vv[i].size();
if (!sz[1] && !sz[2]) {
if (!sz[0] || !sz[3]) return puts("0");
return puts("-1");
} else {
pair<int, int> p;
p = sz[1] > sz[2] ? pair<int, int>(sz[1] - sz[2], 1)
: pair<int, int>(sz[2] - sz[1], 2);
p.first /= 2;
for (int i = 0; i < n; ++i) ans[i] = 0;
int cnt(0);
for (int i = 0; i < sz[p.second]; ++i) {
if (!p.first) break;
if (!vis[vv[p.second][i]]) {
ans[cnt++] = vv[p.second][i];
p.first--;
}
}
if (p.first)
return puts("-1");
else {
cout << cnt << '\n';
for (int i = 0; i < cnt; ++i) cout << ans[i] << ' ';
cout << '\n';
return 0;
}
}
}
int main() {
int _;
cin >> _;
while (_--) solve();
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
There is a tree with N vertices. The vertices are numbered 1 through N. For each 1 ≤ i ≤ N - 1, the i-th edge connects vertices a_i and b_i. The lengths of all the edges are 1.
Snuke likes some of the vertices. The information on his favorite vertices are given to you as a string s of length N. For each 1 ≤ i ≤ N, s_i is `1` if Snuke likes vertex i, and `0` if he does not like vertex i.
Initially, all the vertices are white. Snuke will perform the following operation exactly once:
* Select a vertex v that he likes, and a non-negative integer d. Then, paint all the vertices black whose distances from v are at most d.
Find the number of the possible combinations of colors of the vertices after the operation.
Constraints
* 2 ≤ N ≤ 2×10^5
* 1 ≤ a_i, b_i ≤ N
* The given graph is a tree.
* |s| = N
* s consists of `0` and `1`.
* s contains at least one occurrence of `1`.
Input
The input is given from Standard Input in the following format:
N
a_1 b_1
a_2 b_2
:
a_{N - 1} b_{N - 1}
s
Output
Print the number of the possible combinations of colors of the vertices after the operation.
Examples
Input
4
1 2
1 3
1 4
1100
Output
4
Input
5
1 2
1 3
1 4
4 5
11111
Output
11
Input
6
1 2
1 3
1 4
2 5
2 6
100011
Output
8
### Response
```cpp
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cassert>
#include <cctype>
using namespace std;
typedef long long lint;
#define cout cerr
#define ni (next_num<int>())
template<class T>inline T next_num(){
T i=0;char c;
while(!isdigit(c=getchar())&&c!='-');
bool flag=c=='-';
flag?c=getchar():0;
while(i=i*10-'0'+c,isdigit(c=getchar()));
return flag?-i:i;
}
template<class T1,class T2>inline void apmax(T1 &a,const T2 &b){if(a<b)a=b;}
template<class T1,class T2>inline void apmin(T1 &a,const T2 &b){if(b<a)a=b;}
const int N=200010,INF=0x7f7f7f7f;
lint ans=1;
char s[N];
int onecnt=0;
namespace T{
const int E=N<<1;
int to[E],bro[E],head[N],e=0;
inline void init(){
memset(head,-1,sizeof(head));
}
inline void ae(int u,int v){
to[e]=v,bro[e]=head[u],head[u]=e++;
}
inline void add(int u,int v){
ae(u,v),ae(v,u);
}
int dep[E],cnt[E];
void dfs1(int x,int e){
if(~e){
dep[e]=1;
cnt[e]=s[x]=='1';
}
for(int i=head[x],v;~i;i=bro[i]){
if(i^e^1){
dfs1(v=to[i],i);
if(~e){
cnt[e]+=cnt[i];
apmax(dep[e],dep[i]+1);
}
}
}
if(~e){
cnt[e^1]=onecnt-cnt[e];
}
}
void dfs2(int x,int fa){
int mx1=0,mx2=0,mn=s[x]=='1'?0:INF;
int fr=0;
for(int i=head[x];~i;i=bro[i]){
if(dep[i]>mx1){
mx2=mx1,mx1=dep[i];
fr=i;
}else if(dep[i]>mx2){
mx2=dep[i];
}
if(cnt[i]){
apmin(mn,dep[i]);
}
}
ans+=max(min(mx1-1,mx2+1)-mn+1,0);
for(int i=head[x],v;~i;i=bro[i]){
if((v=to[i])!=fa){
dep[i^1]=(fr!=i?mx1:mx2)+1;
dfs2(v,x);
}
}
}
}
inline lint Main(){
int n=ni;
T::init();
for(int i=1;i<n;i++){
T::add(ni,ni);
}
scanf("%s",s+1);
for(int i=1;i<=n;i++){
onecnt+=s[i]=='1';
}
T::dfs1(1,-1),T::dfs2(1,0);
return ans;
}
int main(){
printf("%lld\n",Main());
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
It is known that the area of a regular dodecagon inscribed in a circle of radius a is 3a^2.
Given an integer r, find the area of a regular dodecagon inscribed in a circle of radius r.
Constraints
* 1 \leq r \leq 100
* r is an integer.
Input
Input is given from Standard Input in the following format:
r
Output
Print an integer representing the area of the regular dodecagon.
Examples
Input
4
Output
48
Input
15
Output
675
Input
80
Output
19200
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
int a;cin >> a;printf("%d\n",3*a*a);
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
You are given a tree T with N vertices and an undirected graph G with N vertices and M edges. The vertices of each graph are numbered 1 to N. The i-th of the N-1 edges in T connects Vertex a_i and Vertex b_i, and the j-th of the M edges in G connects Vertex c_j and Vertex d_j.
Consider adding edges to G by repeatedly performing the following operation:
* Choose three integers a, b and c such that G has an edge connecting Vertex a and b and an edge connecting Vertex b and c but not an edge connecting Vertex a and c. If there is a simple path in T that contains all three of Vertex a, b and c in some order, add an edge in G connecting Vertex a and c.
Print the number of edges in G when no more edge can be added. It can be shown that this number does not depend on the choices made in the operation.
Constraints
* 2 \leq N \leq 2000
* 1 \leq M \leq 2000
* 1 \leq a_i, b_i \leq N
* a_i \neq b_i
* 1 \leq c_j, d_j \leq N
* c_j \neq d_j
* G does not contain multiple edges.
* T is a tree.
Input
Input is given from Standard Input in the following format:
N M
a_1 b_1
:
a_{N-1} b_{N-1}
c_1 d_1
:
c_M d_M
Output
Print the final number of edges in G.
Examples
Input
5 3
1 2
1 3
3 4
1 5
5 4
2 5
1 5
Output
6
Input
7 5
1 5
1 4
1 7
1 2
2 6
6 3
2 5
1 3
1 6
4 6
4 7
Output
11
Input
13 11
6 13
1 2
5 1
8 4
9 7
12 2
10 11
1 9
13 7
13 11
8 10
3 8
4 13
8 12
4 7
2 3
5 11
1 4
2 11
8 10
3 5
6 9
4 10
Output
27
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
const int N=2e3+10;
typedef vector<int> vi;
typedef pair<int,int> pii;
#define pb push_back
#define mp make_pair
#define fi first
#define se second
int gi() {
int x=0,o=1;char ch=getchar();
while(!isdigit(ch)&&ch!='-') ch=getchar();
if(ch=='-') o=-1,ch=getchar();
while(isdigit(ch)) x=x*10+ch-'0',ch=getchar();
return x*o;
}
int n,m,fa[N][N],top[N][N],ans;
vi E[N];
bool G[N][N];
void dfs(int u,int ff,int t) {
fa[t][u]=ff;
for(auto v:E[u])
if(v^ff) dfs(v,u,t);
}
void add(int x,int y) {
if(G[x][y]||x==y) return;
if(~top[x][y]) add(top[x][y],y);
else if(~top[y][x]) add(top[y][x],x);
else {
vector<pii> e;
for(int i=0;i<2;i++) {
top[x][y]=y;G[x][y]=1;
queue<int> q;q.push(y);
while(!q.empty()) {
int u=q.front();q.pop();
for(auto v:E[u])
if(v^fa[x][u]) {
if(!~top[x][v]) top[x][v]=y,q.push(v);
else if(G[x][v]) {
G[x][v]=G[v][x]=0;top[x][v]=top[v][x]=-1;e.pb(mp(y,v));
}
}
}
swap(x,y);
}
for(auto x:e) add(x.fi,x.se);
}
}
void dfs2(int u,int ff,int t) {
if(top[t][u]==u) ++ans,t=u;
for(auto v:E[u])
if(v^ff) dfs2(v,u,t);
}
int main() {
cin>>n>>m;
for(int i=1,u,v;i<n;i++) u=gi(),v=gi(),E[u].pb(v),E[v].pb(u);
for(int i=1;i<=n;i++) dfs(i,0,i);
memset(top,-1,sizeof(top));
for(int i=1,u,v;i<=m;i++) u=gi(),v=gi(),add(u,v);
for(int i=1;i<=n;i++)
for(auto j:E[i]) dfs2(j,i,i);
cout<<ans/2;
return 0;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
It's time polar bears Menshykov and Uslada from the zoo of St. Petersburg and elephant Horace from the zoo of Kiev got down to business. In total, there are n tasks for the day and each animal should do each of these tasks. For each task, they have evaluated its difficulty. Also animals decided to do the tasks in order of their difficulty. Unfortunately, some tasks can have the same difficulty, so the order in which one can perform the tasks may vary.
Menshykov, Uslada and Horace ask you to deal with this nuisance and come up with individual plans for each of them. The plan is a sequence describing the order in which an animal should do all the n tasks. Besides, each of them wants to have its own unique plan. Therefore three plans must form three different sequences. You are to find the required plans, or otherwise deliver the sad news to them by stating that it is impossible to come up with three distinct plans for the given tasks.
Input
The first line contains integer n (1 ≤ n ≤ 2000) — the number of tasks. The second line contains n integers h1, h2, ..., hn (1 ≤ hi ≤ 2000), where hi is the difficulty of the i-th task. The larger number hi is, the more difficult the i-th task is.
Output
In the first line print "YES" (without the quotes), if it is possible to come up with three distinct plans of doing the tasks. Otherwise print in the first line "NO" (without the quotes). If three desired plans do exist, print in the second line n distinct integers that represent the numbers of the tasks in the order they are done according to the first plan. In the third and fourth line print two remaining plans in the same form.
If there are multiple possible answers, you can print any of them.
Examples
Input
4
1 3 3 1
Output
YES
1 4 2 3
4 1 2 3
4 1 3 2
Input
5
2 4 1 4 8
Output
NO
Note
In the first sample the difficulty of the tasks sets one limit: tasks 1 and 4 must be done before tasks 2 and 3. That gives the total of four possible sequences of doing tasks : [1, 4, 2, 3], [4, 1, 2, 3], [1, 4, 3, 2], [4, 1, 3, 2]. You can print any three of them in the answer.
In the second sample there are only two sequences of tasks that meet the conditions — [3, 1, 2, 4, 5] and [3, 1, 4, 2, 5]. Consequently, it is impossible to make three distinct sequences of tasks.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct node {
int x, y;
} a[2010];
int cmp(node x, node y) { return x.x < y.x; }
node a1[2010], a2[2010], a3[2010];
int main() {
int m, n, i, j, k;
while (scanf("%d", &n) != -1) {
memset(a, 0, sizeof(a));
for (i = 1; i <= n; i++) {
scanf("%d", &a[i].x);
a[i].y = i;
}
sort(a + 1, a + 1 + n, cmp);
for (i = 1; i <= n; i++) {
a1[i].y = a[i].y;
a1[i].x = a[i].x;
}
int flag = 0;
for (i = 1; i <= n; i++) {
if (a1[i].x == a1[i + 1].x && !flag) {
k = i;
flag = 1;
a2[i].y = a1[i + 1].y;
a2[i + 1].y = a1[i].y;
i++;
continue;
}
a2[i].x = a1[i].x;
a2[i].y = a1[i].y;
}
if (flag == 0) {
printf("NO\n");
continue;
}
for (i = 1; i <= n; i++) {
if (a1[i].x == a1[i + 1].x && i != k && flag == 1) {
flag = 2;
a3[i].y = a1[i + 1].y;
a3[i + 1].y = a1[i].y;
i++;
continue;
}
a3[i].y = a1[i].y;
}
if (flag != 2) {
printf("NO\n");
continue;
}
printf("YES\n");
for (i = 1; i <= n; i++)
if (i == 1)
printf("%d", a1[i].y);
else
printf(" %d", a1[i].y);
printf("\n");
for (i = 1; i <= n; i++)
if (i == 1)
printf("%d", a2[i].y);
else
printf(" %d", a2[i].y);
printf("\n");
for (i = 1; i <= n; i++)
if (i == 1)
printf("%d", a3[i].y);
else
printf(" %d", a3[i].y);
printf("\n");
}
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Harry, Ron and Hermione have figured out that Helga Hufflepuff's cup is a horcrux. Through her encounter with Bellatrix Lestrange, Hermione came to know that the cup is present in Bellatrix's family vault in Gringott's Wizarding Bank.
The Wizarding bank is in the form of a tree with total n vaults where each vault has some type, denoted by a number between 1 to m. A tree is an undirected connected graph with no cycles.
The vaults with the highest security are of type k, and all vaults of type k have the highest security.
There can be at most x vaults of highest security.
Also, if a vault is of the highest security, its adjacent vaults are guaranteed to not be of the highest security and their type is guaranteed to be less than k.
Harry wants to consider every possibility so that he can easily find the best path to reach Bellatrix's vault. So, you have to tell him, given the tree structure of Gringotts, the number of possible ways of giving each vault a type such that the above conditions hold.
Input
The first line of input contains two space separated integers, n and m — the number of vaults and the number of different vault types possible. (1 ≤ n ≤ 105, 1 ≤ m ≤ 109).
Each of the next n - 1 lines contain two space separated integers ui and vi (1 ≤ ui, vi ≤ n) representing the i-th edge, which shows there is a path between the two vaults ui and vi. It is guaranteed that the given graph is a tree.
The last line of input contains two integers k and x (1 ≤ k ≤ m, 1 ≤ x ≤ 10), the type of the highest security vault and the maximum possible number of vaults of highest security.
Output
Output a single integer, the number of ways of giving each vault a type following the conditions modulo 109 + 7.
Examples
Input
4 2
1 2
2 3
1 4
1 2
Output
1
Input
3 3
1 2
1 3
2 1
Output
13
Input
3 1
1 2
1 3
1 1
Output
0
Note
In test case 1, we cannot have any vault of the highest security as its type is 1 implying that its adjacent vaults would have to have a vault type less than 1, which is not allowed. Thus, there is only one possible combination, in which all the vaults have type 2.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long pwr(long long base, long long p, long long mod = (1000000007LL)) {
long long ans = 1;
while (p) {
if (p & 1) ans = (ans * base) % mod;
base = (base * base) % mod;
p /= 2;
}
return ans;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
const int N = 100002;
int n, m, k, x;
long long DP[N][3][12], storage[3][12];
vector<int> adj[N];
void dfs(int v, int par) {
DP[v][0][0] = k - 1;
DP[v][1][1] = 1;
DP[v][2][0] = m - k;
for (auto vv : adj[v]) {
if (vv == par) continue;
dfs(vv, v);
memset(storage, 0, sizeof(storage));
for (int j = 0; j <= x; j++)
for (int k = 0; k <= x; k++) {
if (j + k <= x)
storage[0][j + k] =
(storage[0][j + k] +
DP[v][0][j] * (DP[vv][0][k] + DP[vv][1][k] + DP[vv][2][k])) %
(1000000007LL);
if (j + k <= x)
storage[1][j + k] =
(storage[1][j + k] + DP[v][1][j] * DP[vv][0][k]) % (1000000007LL);
if (j + k <= x)
storage[2][j + k] = (storage[2][j + k] +
DP[v][2][j] * (DP[vv][0][k] + DP[vv][2][k])) %
(1000000007LL);
}
for (int j = 0; j <= x; j++) {
DP[v][0][j] = storage[0][j];
DP[v][1][j] = storage[1][j];
DP[v][2][j] = storage[2][j];
}
}
}
int main() {
scanf("%d%d", &n, &m);
int e = n - 1;
while (e--) {
int a, b;
scanf("%d%d", &a, &b);
adj[a].push_back(b);
adj[b].push_back(a);
}
scanf("%d%d", &k, &x);
dfs(1, -1);
long long ans = 0;
for (int j = 0; j <= x; j++) {
ans = (ans + DP[1][0][j]) % (1000000007LL);
ans = (ans + DP[1][1][j]) % (1000000007LL);
ans = (ans + DP[1][2][j]) % (1000000007LL);
}
ans %= (1000000007LL);
ans += (1000000007LL);
ans %= (1000000007LL);
printf("%lld\n", ans);
return 0;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
— Hey folks, how do you like this problem?
— That'll do it.
BThero is a powerful magician. He has got n piles of candies, the i-th pile initially contains a_i candies. BThero can cast a copy-paste spell as follows:
1. He chooses two piles (i, j) such that 1 ≤ i, j ≤ n and i ≠ j.
2. All candies from pile i are copied into pile j. Formally, the operation a_j := a_j + a_i is performed.
BThero can cast this spell any number of times he wants to — but unfortunately, if some pile contains strictly more than k candies, he loses his magic power. What is the maximum number of times BThero can cast the spell without losing his power?
Input
The first line contains one integer T (1 ≤ T ≤ 500) — the number of test cases.
Each test case consists of two lines:
* the first line contains two integers n and k (2 ≤ n ≤ 1000, 2 ≤ k ≤ 10^4);
* the second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ k).
It is guaranteed that the sum of n over all test cases does not exceed 1000, and the sum of k over all test cases does not exceed 10^4.
Output
For each test case, print one integer — the maximum number of times BThero can cast the spell without losing his magic power.
Example
Input
3
2 2
1 1
3 5
1 2 3
3 7
3 2 2
Output
1
5
4
Note
In the first test case we get either a = [1, 2] or a = [2, 1] after casting the spell for the first time, and it is impossible to cast it again.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n, k, a;
cin >> t;
while (t--) {
cin >> n >> k;
vector<int> candie;
for (int i = 0; i < n; i++) {
cin >> a;
candie.push_back(a);
}
sort(candie.begin(), candie.end());
long long out = 0;
for (int i = 1; i < n; i++) {
out += (k - candie[i]) / candie[0];
}
printf("%lld\n", out);
}
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
The board has got a painted tree graph, consisting of n nodes. Let us remind you that a non-directed graph is called a tree if it is connected and doesn't contain any cycles.
Each node of the graph is painted black or white in such a manner that there aren't two nodes of the same color, connected by an edge. Each edge contains its value written on it as a non-negative integer.
A bad boy Vasya came up to the board and wrote number sv near each node v — the sum of values of all edges that are incident to this node. Then Vasya removed the edges and their values from the board.
Your task is to restore the original tree by the node colors and numbers sv.
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 105) — the number of nodes in the tree. Next n lines contain pairs of space-separated integers ci, si (0 ≤ ci ≤ 1, 0 ≤ si ≤ 109), where ci stands for the color of the i-th vertex (0 is for white, 1 is for black), and si represents the sum of values of the edges that are incident to the i-th vertex of the tree that is painted on the board.
Output
Print the description of n - 1 edges of the tree graph. Each description is a group of three integers vi, ui, wi (1 ≤ vi, ui ≤ n, vi ≠ ui, 0 ≤ wi ≤ 109), where vi and ui — are the numbers of the nodes that are connected by the i-th edge, and wi is its value. Note that the following condition must fulfill cvi ≠ cui.
It is guaranteed that for any input data there exists at least one graph that meets these data. If there are multiple solutions, print any of them. You are allowed to print the edges in any order. As you print the numbers, separate them with spaces.
Examples
Input
3
1 3
1 2
0 5
Output
3 1 3
3 2 2
Input
6
1 0
0 3
1 8
0 2
0 3
0 0
Output
2 3 3
5 3 3
4 3 2
1 6 0
2 1 0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, w;
priority_queue<pair<int, int> > pq[2];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
int a, b;
scanf("%d%d", &a, &b);
pq[a].push(make_pair(-b, i));
}
w = 0;
for (int i = 1; i <= n - 1; ++i) {
if (-pq[w].top().first < -pq[w ^ 1].top().first) w ^= 1;
if ((pq[w].top().first == pq[w ^ 1].top().first) &&
(pq[w].size() > pq[w ^ 1].size()))
w ^= 1;
int a = -pq[w].top().first;
int b = pq[w].top().second;
printf("%d %d %d\n", pq[w].top().second, pq[w ^ 1].top().second,
-pq[w ^ 1].top().first);
a -= -pq[w ^ 1].top().first;
pq[0].pop();
pq[1].pop();
pq[w].push(make_pair(-a, b));
}
return 0;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
Programmer Rostislav got seriously interested in the Link/Cut Tree data structure, which is based on Splay trees. Specifically, he is now studying the expose procedure.
Unfortunately, Rostislav is unable to understand the definition of this procedure, so he decided to ask programmer Serezha to help him. Serezha agreed to help if Rostislav solves a simple task (and if he doesn't, then why would he need Splay trees anyway?)
Given integers l, r and k, you need to print all powers of number k within range from l to r inclusive. However, Rostislav doesn't want to spent time doing this, as he got interested in playing a network game called Agar with Gleb. Help him!
Input
The first line of the input contains three space-separated integers l, r and k (1 ≤ l ≤ r ≤ 1018, 2 ≤ k ≤ 109).
Output
Print all powers of number k, that lie within range from l to r in the increasing order. If there are no such numbers, print "-1" (without the quotes).
Examples
Input
1 10 2
Output
1 2 4 8
Input
2 4 5
Output
-1
Note
Note to the first sample: numbers 20 = 1, 21 = 2, 22 = 4, 23 = 8 lie within the specified range. The number 24 = 16 is greater then 10, thus it shouldn't be printed.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
long long int l, r, k, x, num, temp;
cin >> l >> r >> k;
x = (double(log(l) / log(k)));
num = 1;
bool flag = 0;
while (num <= r) {
if (num >= l) {
cout << num << " ";
flag = 1;
}
temp = num * k;
if (temp / num != k) break;
num = temp;
}
if (flag == 0) {
cout << "-1";
}
return 0;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
First-rate specialists graduate from Berland State Institute of Peace and Friendship. You are one of the most talented students in this university. The education is not easy because you need to have fundamental knowledge in different areas, which sometimes are not related to each other.
For example, you should know linguistics very well. You learn a structure of Reberland language as foreign language. In this language words are constructed according to the following rules. First you need to choose the "root" of the word — some string which has more than 4 letters. Then several strings with the length 2 or 3 symbols are appended to this word. The only restriction — it is not allowed to append the same string twice in a row. All these strings are considered to be suffixes of the word (this time we use word "suffix" to describe a morpheme but not the few last characters of the string as you may used to).
Here is one exercise that you have found in your task list. You are given the word s. Find all distinct strings with the length 2 or 3, which can be suffixes of this word according to the word constructing rules in Reberland language.
Two strings are considered distinct if they have different length or there is a position in which corresponding characters do not match.
Let's look at the example: the word abacabaca is given. This word can be obtained in the following ways: <image>, where the root of the word is overlined, and suffixes are marked by "corners". Thus, the set of possible suffixes for this word is {aca, ba, ca}.
Input
The only line contains a string s (5 ≤ |s| ≤ 104) consisting of lowercase English letters.
Output
On the first line print integer k — a number of distinct possible suffixes. On the next k lines print suffixes.
Print suffixes in lexicographical (alphabetical) order.
Examples
Input
abacabaca
Output
3
aca
ba
ca
Input
abaca
Output
0
Note
The first test was analysed in the problem statement.
In the second example the length of the string equals 5. The length of the root equals 5, so no string can be used as a suffix.
### Response
```cpp
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
using ll = long long;
const char E = '\n';
const int N = 10005;
const ll mod = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s;
bool dp[N][2] = {0};
set<string> u;
int n;
cin >> s;
n = s.size();
s = '#' + s + '#' + '#' + '#';
dp[n + 1][0] = dp[n + 1][1] = 1;
for (int i = n; i >= 7; i--) {
string x, y, x1, y1;
x = s[i - 1];
x += s[i];
y = s[i - 2];
y += s[i - 1];
y += s[i];
x1 = s[i + 1];
x1 += s[i + 2];
y1 = s[i + 1];
y1 += s[i + 2];
y1 += s[i + 3];
if ((x != x1 && (dp[i + 1][0] || dp[i + 1][1])) ||
(x == x1 && dp[i + 1][1])) {
dp[i - 1][0] = 1;
u.insert(x);
}
if (i > 7)
if ((y != y1 && (dp[i + 1][0] || dp[i + 1][1])) ||
(y == y1 && dp[i + 1][0])) {
dp[i - 2][1] = 1;
u.insert(y);
}
}
cout << u.size() << E;
for (auto i : u) {
cout << i << E;
}
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
In this problem you will meet the simplified model of game Pudding Monsters.
An important process in developing any game is creating levels. A game field in Pudding Monsters is an n × n rectangular grid, n of its cells contain monsters and some other cells contain game objects. The gameplay is about moving the monsters around the field. When two monsters are touching each other, they glue together into a single big one (as they are from pudding, remember?).
<image>
Statistics showed that the most interesting maps appear if initially each row and each column contains exactly one monster and the rest of map specifics is set up by the correct positioning of the other game objects.
A technique that's widely used to make the development process more efficient is reusing the available resources. For example, if there is a large n × n map, you can choose in it a smaller k × k square part, containing exactly k monsters and suggest it as a simplified version of the original map.
You wonder how many ways there are to choose in the initial map a k × k (1 ≤ k ≤ n) square fragment, containing exactly k pudding monsters. Calculate this number.
Input
The first line contains a single integer n (1 ≤ n ≤ 3 × 105) — the size of the initial field.
Next n lines contain the coordinates of the cells initially containing monsters. The i-th of the next lines contains two numbers ri, ci (1 ≤ ri, ci ≤ n) — the row number and the column number of the cell that initially contains the i-th monster.
It is guaranteed that all ri are distinct numbers and all ci are distinct numbers.
Output
Print the number of distinct square fragments of the original field that can form a new map.
Examples
Input
5
1 1
4 3
3 2
2 4
5 5
Output
10
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 300005;
pair<int, int> st[4 * N];
int lz[4 * N];
void prop(int p, int L, int R) {
if (lz[p]) {
st[p].first += lz[p];
if (L < R) {
lz[2 * p] += lz[p];
lz[2 * p + 1] += lz[p];
}
lz[p] = 0;
}
}
pair<int, int> comb(const pair<int, int> &a, const pair<int, int> &b) {
if (a.first < b.first) return a;
if (b.first < a.first) return b;
return {a.first, a.second + b.second};
}
void upd(int p, int L, int R, int i, int j, int val) {
prop(p, L, R);
if (i > R or j < L) return;
if (L >= i and R <= j) {
lz[p] = val;
prop(p, L, R);
return;
}
int mid = (L + R) / 2;
upd(2 * p, L, mid, i, j, val);
upd(2 * p + 1, mid + 1, R, i, j, val);
st[p] = comb(st[2 * p], st[2 * p + 1]);
}
pair<int, int> query(int p, int L, int R, int i, int j) {
prop(p, L, R);
if (i > R or j < L) return make_pair(int(1e9), 0);
if (L >= i and R <= j) return st[p];
int mid = (L + R) / 2;
return comb(query(2 * p, L, mid, i, j), query(2 * p + 1, mid + 1, R, i, j));
}
void build(int p, int L, int R) {
if (L == R) {
st[p] = {-L, 1};
return;
}
int mid = (L + R) / 2;
build(2 * p, L, mid);
build(2 * p + 1, mid + 1, R);
st[p] = comb(st[2 * p], st[2 * p + 1]);
}
int main() {
int n;
scanf("%d", &n);
vector<int> a(n);
{
vector<pair<int, int>> tmp(n);
for (auto &p : tmp) scanf("%d %d", &p.first, &p.second);
sort(tmp.begin(), tmp.end());
for (int i = 0; i < n; i++) a[i] = tmp[i].second;
}
build(1, 0, n - 1);
vector<int> rigmn(n), rigmx(n);
stack<int> smx, smn;
ll ans = 0;
for (int i = n - 1; i >= 0; i--) {
while (!smx.empty() and a[smx.top()] < a[i]) {
int id = smx.top();
smx.pop();
int nx = smx.empty() ? n - 1 : smx.top() - 1;
upd(1, 0, n - 1, id, nx, -a[id]);
}
while (!smn.empty() and a[smn.top()] > a[i]) {
int id = smn.top();
smn.pop();
int nx = smn.empty() ? n - 1 : smn.top() - 1;
upd(1, 0, n - 1, id, nx, a[id]);
}
rigmn[i] = smn.empty() ? n - 1 : smn.top() - 1;
rigmx[i] = smx.empty() ? n - 1 : smx.top() - 1;
smx.push(i);
smn.push(i);
upd(1, 0, n - 1, i, rigmn[i], -a[i]);
upd(1, 0, n - 1, i, rigmx[i], a[i]);
auto tmp = query(1, 0, n - 1, i, n - 1);
if (tmp.first == -i) {
ans += tmp.second;
}
}
printf("%lld\n", ans);
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
After making bad dives into swimming pools, Wilbur wants to build a swimming pool in the shape of a rectangle in his backyard. He has set up coordinate axes, and he wants the sides of the rectangle to be parallel to them. Of course, the area of the rectangle must be positive. Wilbur had all four vertices of the planned pool written on a paper, until his friend came along and erased some of the vertices.
Now Wilbur is wondering, if the remaining n vertices of the initial rectangle give enough information to restore the area of the planned swimming pool.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 4) — the number of vertices that were not erased by Wilbur's friend.
Each of the following n lines contains two integers xi and yi ( - 1000 ≤ xi, yi ≤ 1000) —the coordinates of the i-th vertex that remains. Vertices are given in an arbitrary order.
It's guaranteed that these points are distinct vertices of some rectangle, that has positive area and which sides are parallel to the coordinate axes.
Output
Print the area of the initial rectangle if it could be uniquely determined by the points remaining. Otherwise, print - 1.
Examples
Input
2
0 0
1 1
Output
1
Input
1
1 1
Output
-1
Note
In the first sample, two opposite corners of the initial rectangle are given, and that gives enough information to say that the rectangle is actually a unit square.
In the second sample there is only one vertex left and this is definitely not enough to uniquely define the area.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
int t1, t2;
set<int> xs, ys;
for (long long i = 0; i < n; i++) {
cin >> t1 >> t2;
xs.insert(t1);
ys.insert(t2);
}
if (xs.size() == 2 && ys.size() == 2) {
auto it1 = xs.begin(), it2 = ys.begin();
int ans = abs(*(it1++) - *it1) * abs(*(it2++) - *it2);
cout << ans;
} else {
cout << -1;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
Dima got into number sequences. Now he's got sequence a1, a2, ..., an, consisting of n positive integers. Also, Dima has got a function f(x), which can be defined with the following recurrence:
* f(0) = 0;
* f(2·x) = f(x);
* f(2·x + 1) = f(x) + 1.
Dima wonders, how many pairs of indexes (i, j) (1 ≤ i < j ≤ n) are there, such that f(ai) = f(aj). Help him, count the number of such pairs.
Input
The first line contains integer n (1 ≤ n ≤ 105). The second line contains n positive integers a1, a2, ..., an (1 ≤ ai ≤ 109).
The numbers in the lines are separated by single spaces.
Output
In a single line print the answer to the problem.
Please, don't use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
3
1 2 4
Output
3
Input
3
5 3 1
Output
1
Note
In the first sample any pair (i, j) will do, so the answer is 3.
In the second sample only pair (1, 2) will do.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int i, j, k, l, m, n, k2, c;
cin >> n;
long long int ar[100] = {0};
for (i = 0; i < n; i++) {
cin >> k2;
c = 0;
while (k2 > 0) {
if (k2 & 1) c++;
k2 = k2 >> 1;
}
ar[c]++;
}
long long int ans = 0;
for (i = 0; i < 100; i++) {
ans += (ar[i] * (ar[i] - 1)) / 2;
}
cout << ans;
return 0;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
The Smart Beaver from ABBYY has a long history of cooperating with the "Institute of Cytology and Genetics". Recently, the Institute staff challenged the Beaver with a new problem. The problem is as follows.
There is a collection of n proteins (not necessarily distinct). Each protein is a string consisting of lowercase Latin letters. The problem that the scientists offered to the Beaver is to select a subcollection of size k from the initial collection of proteins so that the representativity of the selected subset of proteins is maximum possible.
The Smart Beaver from ABBYY did some research and came to the conclusion that the representativity of a collection of proteins can be evaluated by a single number, which is simply calculated. Let's suppose we have a collection {a1, ..., ak} consisting of k strings describing proteins. The representativity of this collection is the following value:
<image>
where f(x, y) is the length of the longest common prefix of strings x and y; for example, f("abc", "abd") = 2, and f("ab", "bcd") = 0.
Thus, the representativity of collection of proteins {"abc", "abd", "abe"} equals 6, and the representativity of collection {"aaa", "ba", "ba"} equals 2.
Having discovered that, the Smart Beaver from ABBYY asked the Cup contestants to write a program that selects, from the given collection of proteins, a subcollection of size k which has the largest possible value of representativity. Help him to solve this problem!
Input
The first input line contains two integers n and k (1 ≤ k ≤ n), separated by a single space. The following n lines contain the descriptions of proteins, one per line. Each protein is a non-empty string of no more than 500 characters consisting of only lowercase Latin letters (a...z). Some of the strings may be equal.
The input limitations for getting 20 points are:
* 1 ≤ n ≤ 20
The input limitations for getting 50 points are:
* 1 ≤ n ≤ 100
The input limitations for getting 100 points are:
* 1 ≤ n ≤ 2000
Output
Print a single number denoting the largest possible value of representativity that a subcollection of size k of the given collection of proteins can have.
Examples
Input
3 2
aba
bzd
abq
Output
2
Input
4 3
eee
rrr
ttt
qqq
Output
0
Input
4 3
aaa
abba
abbc
abbd
Output
9
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 2000 + 10;
int n, k;
string a[N];
int lcp[N];
int tot, f[N * 3][N];
int *solve(int l, int r) {
int *ff = f[++tot];
if (l == r) return ff;
int w = l + 1;
for (int i = (l + 1); i <= (r); i++)
if (lcp[i] < lcp[w]) w = i;
int *fl = solve(l, w - 1), *fr = solve(w, r), n = r - l + 1;
for (int k = (1); k <= (n); k++)
for (int k1 = (0); k1 <= (k); k1++)
ff[k] = max(ff[k], fl[k1] + fr[k - k1] + k1 * (k - k1) * lcp[w]);
return ff;
}
int main() {
cin >> n >> k;
for (int i = (1); i <= (n); i++) cin >> a[i];
sort(a + 1, a + n + 1);
for (int i = (2); i <= (n); i++)
for (int j = (1);
j <= (min(((int)(a[i]).size()), ((int)(a[i - 1]).size()))); j++)
if (a[i][j - 1] != a[i - 1][j - 1])
break;
else
lcp[i] = j;
cout << solve(1, n)[k] << endl;
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
Limak is a little grizzly bear. He will once attack Deerland but now he can only destroy trees in role-playing games. Limak starts with a tree with one vertex. The only vertex has index 1 and is a root of the tree.
Sometimes, a game chooses a subtree and allows Limak to attack it. When a subtree is attacked then each of its edges is destroyed with probability <image>, independently of other edges. Then, Limak gets the penalty — an integer equal to the height of the subtree after the attack. The height is defined as the maximum number of edges on the path between the root of the subtree and any vertex in the subtree.
You must handle queries of two types.
* 1 v denotes a query of the first type. A new vertex appears and its parent is v. A new vertex has the next available index (so, new vertices will be numbered 2, 3, ...).
* 2 v denotes a query of the second type. For a moment let's assume that the game allows Limak to attack a subtree rooted in v. Then, what would be the expected value of the penalty Limak gets after the attack?
In a query of the second type, Limak doesn't actually attack the subtree and thus the query doesn't affect next queries.
Input
The first line of the input contains one integer q (1 ≤ q ≤ 500 000) — the number of queries.
Then, q lines follow. The i-th of them contains two integers typei and vi (1 ≤ typei ≤ 2). If typei = 1 then vi denotes a parent of a new vertex, while if typei = 2 then you should print the answer for a subtree rooted in vi.
It's guaranteed that there will be at least 1 query of the second type, that is, the output won't be empty.
It's guaranteed that just before the i-th query a vertex vi already exists.
Output
For each query of the second type print one real number —the expected value of the penalty if Limak attacks the given subtree. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
7
1 1
1 1
2 1
1 2
1 3
2 2
2 1
Output
0.7500000000
0.5000000000
1.1875000000
Input
8
2 1
1 1
1 2
1 3
1 4
2 1
1 4
2 1
Output
0.0000000000
0.9375000000
0.9687500000
Note
Below, you can see the drawing for the first sample. Red circles denote queries of the second type.
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
double dp[500010][41];
int n, T, fa[500010];
void dfs(int x, int i, double tmp) {
if (i == 41) return;
if (x == 0) return;
double t = dp[x][i];
dp[x][i] *= tmp;
dfs(fa[x], i + 1, (dp[x][i] + 1) / (t + 1));
}
int main() {
scanf("%d", &T);
n = 1;
for (int i = 0; i <= 40; i++) dp[1][i] = 1;
while (T--) {
int op, v;
scanf("%d%d", &op, &v);
if (op == 1) {
n++;
fa[n] = v;
for (int i = 0; i <= 40; i++) dp[n][i] = 1;
double t = dp[v][0];
dp[v][0] *= 0.5;
dfs(fa[v], 1, (dp[v][0] + 1) / (t + 1));
} else {
double ans = 0;
for (int i = 1; i <= 40; i++)
ans += (double)i * (dp[v][i] - dp[v][i - 1]);
printf("%.10lf\n", ans);
}
}
return 0;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
You are given an array a consisting of n non-negative integers. You have to choose a non-negative integer x and form a new array b of size n according to the following rule: for all i from 1 to n, b_i = a_i ⊕ x (⊕ denotes the operation [bitwise XOR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR)).
An inversion in the b array is a pair of integers i and j such that 1 ≤ i < j ≤ n and b_i > b_j.
You should choose x in such a way that the number of inversions in b is minimized. If there are several options for x — output the smallest one.
Input
First line contains a single integer n (1 ≤ n ≤ 3 ⋅ 10^5) — the number of elements in a.
Second line contains n space-separated integers a_1, a_2, ..., a_n (0 ≤ a_i ≤ 10^9), where a_i is the i-th element of a.
Output
Output two integers: the minimum possible number of inversions in b, and the minimum possible value of x, which achieves those number of inversions.
Examples
Input
4
0 1 3 2
Output
1 0
Input
9
10 7 9 10 7 5 5 3 5
Output
4 14
Input
3
8 10 3
Output
0 8
Note
In the first sample it is optimal to leave the array as it is by choosing x = 0.
In the second sample the selection of x = 14 results in b: [4, 9, 7, 4, 9, 11, 11, 13, 11]. It has 4 inversions:
* i = 2, j = 3;
* i = 2, j = 4;
* i = 3, j = 4;
* i = 8, j = 9.
In the third sample the selection of x = 8 results in b: [0, 2, 11]. It has no inversions.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int temp[300005];
long long _mergeSort(int arr[], int temp[], int left, int right);
long long merge(int arr[], int temp[], int left, int mid, int right);
long long mergeSort(int arr[], int array_size) {
return _mergeSort(arr, temp, 0, array_size - 1);
}
long long _mergeSort(int arr[], int temp[], int left, int right) {
int mid;
long long inv_count = 0;
if (right > left) {
mid = (right + left) / 2;
inv_count += _mergeSort(arr, temp, left, mid);
inv_count += _mergeSort(arr, temp, mid + 1, right);
inv_count += merge(arr, temp, left, mid + 1, right);
}
return inv_count;
}
long long merge(int arr[], int temp[], int left, int mid, int right) {
int i, j, k;
long long inv_count = 0;
i = left;
j = mid;
k = left;
while ((i <= mid - 1) && (j <= right)) {
if (arr[i] <= arr[j]) {
temp[k++] = arr[i++];
} else {
temp[k++] = arr[j++];
inv_count = inv_count + (mid - i);
}
}
while (i <= mid - 1) temp[k++] = arr[i++];
while (j <= right) temp[k++] = arr[j++];
for (i = left; i <= right; i++) arr[i] = temp[i];
return inv_count;
}
int a[300005];
int b[300005];
long long invCount(int a[], int n) {
for (int i = 0; i < n; ++i) {
b[i] = a[i];
}
return mergeSort(b, n);
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
bool fresh = true;
long long ic0 = invCount(a, n);
long long ans = 0;
for (int bit = 29; bit >= 0; --bit) {
if (!fresh) {
ic0 = invCount(a, n);
fresh = true;
}
for (int i = 0; i < n; ++i) {
a[i] ^= (1 << bit);
}
long long ic1 = invCount(a, n);
if (ic1 < ic0) {
ans ^= (1 << bit);
fresh = false;
continue;
}
for (int i = 0; i < n; ++i) {
a[i] ^= (1 << bit);
}
}
cout << invCount(a, n) << " " << ans;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
You are given n integer numbers a_1, a_2, ..., a_n. Consider graph on n nodes, in which nodes i, j (i≠ j) are connected if and only if, a_i AND a_j≠ 0, where AND denotes the [bitwise AND operation](https://en.wikipedia.org/wiki/Bitwise_operation#AND).
Find the length of the shortest cycle in this graph or determine that it doesn't have cycles at all.
Input
The first line contains one integer n (1 ≤ n ≤ 10^5) — number of numbers.
The second line contains n integer numbers a_1, a_2, ..., a_n (0 ≤ a_i ≤ 10^{18}).
Output
If the graph doesn't have any cycles, output -1. Else output the length of the shortest cycle.
Examples
Input
4
3 6 28 9
Output
4
Input
5
5 12 9 16 48
Output
3
Input
4
1 2 4 8
Output
-1
Note
In the first example, the shortest cycle is (9, 3, 6, 28).
In the second example, the shortest cycle is (5, 12, 9).
The graph has no cycles in the third example.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
bool graph[120][120];
int bfs(int startNode, int endNode) {
queue<int> Q;
bool visited[120];
int dist[120];
memset(visited, false, sizeof(visited));
Q.push(startNode);
visited[startNode] = true;
dist[startNode] = 0;
while (!Q.empty()) {
int curr = Q.front();
Q.pop();
if (curr == endNode) {
return dist[curr];
}
for (int i = 0; i < 120; ++i) {
if (!visited[i] && graph[curr][i]) {
visited[i] = true;
dist[i] = dist[curr] + 1;
Q.push(i);
}
}
}
return -1;
}
int main() {
int n;
scanf("%d", &n);
vector<long long> arr;
memset(graph, false, sizeof(graph));
for (int i = 0; i < n; ++i) {
long long temp;
scanf("%lld", &temp);
if (temp > 0) arr.push_back(temp);
}
if (arr.size() > 120) {
printf("3");
return 0;
}
for (int i = 0; i < arr.size(); ++i) {
for (int j = 0; j < arr.size(); ++j) {
for (long long bt = 1; bt <= (1LL << 60); bt *= 2) {
if (i == j) continue;
if ((arr[i] & bt) && (arr[j] & bt)) {
graph[i][j] = true;
}
}
}
}
int best = -1;
for (int i = 0; i < arr.size(); ++i) {
for (int j = 0; j < arr.size(); ++j) {
if (i == j) continue;
if (!graph[i][j]) continue;
graph[i][j] = false;
graph[j][i] = false;
int result = bfs(i, j);
if (result != -1) {
if (best == -1)
best = result + 1;
else
best = min(best, result + 1);
}
graph[i][j] = true;
graph[j][i] = true;
}
}
printf("%d", best);
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
The sequence of m integers is called the permutation if it contains all integers from 1 to m exactly once. The number m is called the length of the permutation.
Dreamoon has two permutations p_1 and p_2 of non-zero lengths l_1 and l_2.
Now Dreamoon concatenates these two permutations into another sequence a of length l_1 + l_2. First l_1 elements of a is the permutation p_1 and next l_2 elements of a is the permutation p_2.
You are given the sequence a, and you need to find two permutations p_1 and p_2. If there are several possible ways to restore them, you should find all of them. (Note that it is also possible that there will be no ways.)
Input
The first line contains an integer t (1 ≤ t ≤ 10 000) denoting the number of test cases in the input.
Each test case contains two lines. The first line contains one integer n (2 ≤ n ≤ 200 000): the length of a. The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ n-1).
The total sum of n is less than 200 000.
Output
For each test case, the first line of output should contain one integer k: the number of ways to divide a into permutations p_1 and p_2.
Each of the next k lines should contain two integers l_1 and l_2 (1 ≤ l_1, l_2 ≤ n, l_1 + l_2 = n), denoting, that it is possible to divide a into two permutations of length l_1 and l_2 (p_1 is the first l_1 elements of a, and p_2 is the last l_2 elements of a). You can print solutions in any order.
Example
Input
6
5
1 4 3 2 1
6
2 4 1 3 2 1
4
2 1 1 3
4
1 3 3 1
12
2 1 3 4 5 6 7 8 9 1 10 2
3
1 1 1
Output
2
1 4
4 1
1
4 2
0
0
1
2 10
0
Note
In the first example, two possible ways to divide a into permutations are \{1\} + \{4, 3, 2, 1\} and \{1,4,3,2\} + \{1\}.
In the second example, the only way to divide a into permutations is \{2,4,1,3\} + \{2,1\}.
In the third example, there are no possible ways.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long int sz = 100005;
const long long int szz = 1000006;
set<long long int> s1, s2;
long long int n;
bool check1(long long int ar[]) {
bool flag = true;
for (long long int i = 0; i < n; i++) {
if (s1.find(ar[i]) == s1.end() and flag) {
s1.insert(ar[i]);
} else {
flag = false;
s2.insert(ar[i]);
}
}
long long int ptr = 1;
for (auto x : s1) {
if (x != ptr) return false;
ptr++;
}
ptr = 1;
for (auto x : s2) {
if (x != ptr) return false;
ptr++;
}
return true;
}
bool check2(long long int ar[]) {
bool flag = true;
for (long long int i = n - 1; i >= 0; i--) {
if (s2.find(ar[i]) == s2.end() and flag) {
s2.insert(ar[i]);
} else
s1.insert(ar[i]), flag = false;
}
long long int ptr = 1;
for (auto x : s1) {
if (x != ptr) return false;
ptr++;
}
ptr = 1;
for (auto x : s2) {
if (x != ptr) return false;
ptr++;
}
return true;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int t;
cin >> t;
while (t--) {
cin >> n;
long long int ar[n];
s1.clear();
s2.clear();
for (long long int i = 0; i < n; i++) {
cin >> ar[i];
}
long long int sz11 = -1, sz12 = -1, sz21 = -1, sz22 = -1;
long long int ans = 0;
if (check1(ar) and
(long long int) s1.size() + (long long int)s2.size() == n) {
sz11 = s1.size();
sz12 = s2.size();
ans++;
}
s1.clear();
s2.clear();
if (check2(ar) and
(long long int) s1.size() + (long long int)s2.size() == n and
(long long int) s1.size() != sz11) {
sz21 = s1.size();
sz22 = s2.size();
ans++;
}
cout << ans << "\n";
if (ans != 0) {
if (sz11 != -1) {
cout << sz11 << " " << sz12 << "\n";
}
if (sz21 != -1) {
cout << sz21 << " " << sz22 << "\n";
}
}
}
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
The Travelling Salesman spends a lot of time travelling so he tends to get bored. To pass time, he likes to perform operations on numbers. One such operation is to take a positive integer x and reduce it to the number of bits set to 1 in the binary representation of x. For example for number 13 it's true that 1310 = 11012, so it has 3 bits set and 13 will be reduced to 3 in one operation.
He calls a number special if the minimum number of operations to reduce it to 1 is k.
He wants to find out how many special numbers exist which are not greater than n. Please help the Travelling Salesman, as he is about to reach his destination!
Since the answer can be large, output it modulo 109 + 7.
Input
The first line contains integer n (1 ≤ n < 21000).
The second line contains integer k (0 ≤ k ≤ 1000).
Note that n is given in its binary representation without any leading zeros.
Output
Output a single integer — the number of special numbers not greater than n, modulo 109 + 7.
Examples
Input
110
2
Output
3
Input
111111011
2
Output
169
Note
In the first sample, the three special numbers are 3, 5 and 6. They get reduced to 2 in one operation (since there are two set bits in each of 3, 5 and 6) and then to 1 in one more operation (since there is only one set bit in 2).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
string n;
int k, num = 0;
long long dp[1001] = {0};
long long comb[1002][1002];
long long ones(long long n) {
long long num = 0LL;
while (n) {
if (n & 1) num++;
n >>= 1;
}
return num;
}
long long solve(long long num) {
long long res = 0LL;
long long s = n.size();
for (int i = 0; i < s; i++) {
if (n[i] == '1') {
res += comb[s - i - 1][num];
num--;
res %= 1000000007;
}
if (num < 0) break;
}
return res + ((num == 0) ? 1 : 0);
}
int main() {
cin >> n >> k;
if (k == 0) {
cout << 1 << endl;
return 0;
}
long long num = 0;
for (int i = 0; i < n.size(); i++)
if (n[i] == '1') num++;
dp[1] = 0;
long long s = n.size();
for (int i = 2; i <= s; i++) {
long long res = ones(i);
dp[i] = dp[res] + 1;
}
comb[0][0] = 1;
for (int i = 1; i < 1001; i++) {
comb[i][0] = 1;
comb[i][1] = i;
comb[i][i] = 1;
}
for (int i = 2; i <= s; i++) {
for (int j = 1; j <= i; j++) {
comb[i][j] = (comb[i - 1][j] + comb[i - 1][j - 1]) % 1000000007;
}
}
long long out = 0LL;
for (int i = 1; i <= s; i++) {
if (dp[i] == k - 1) {
out += solve(i);
}
out %= 1000000007;
}
cout << ((k == 1) ? out - 1 : out) << endl;
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
There are N people, conveniently numbered 1 through N. They were standing in a row yesterday, but now they are unsure of the order in which they were standing. However, each person remembered the following fact: the absolute difference of the number of the people who were standing to the left of that person, and the number of the people who were standing to the right of that person. According to their reports, the difference above for person i is A_i.
Based on these reports, find the number of the possible orders in which they were standing. Since it can be extremely large, print the answer modulo 10^9+7. Note that the reports may be incorrect and thus there may be no consistent order. In such a case, print 0.
Constraints
* 1≦N≦10^5
* 0≦A_i≦N-1
Input
The input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
Output
Print the number of the possible orders in which they were standing, modulo 10^9+7.
Examples
Input
5
2 4 4 0 2
Output
4
Input
7
6 4 0 2 4 0 2
Output
0
Input
8
7 5 1 1 7 3 5 3
Output
16
### Response
```cpp
#include <iostream>
int main(){
int n,t,a=0,i,c[100001]={},inf=1e9+7;
bool f=true;
for(std::cin>>n,i=0;i<n;++i){std::cin>>t;++c[t];}
for(i=0;i<(n+1)/2;++i){
if(n%2){if(c[2*i]!=(i==0?1:2)){f=false;break;}}
else if(c[2*i+1]!=2){f=false;break;}
}
if(f){
a=1;
for(i=0;i<n/2;++i)a=(a*2)%inf;
}
std::cout<<a<<"\n";
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
The New Year holidays are over, but Resha doesn't want to throw away the New Year tree. He invited his best friends Kerim and Gural to help him to redecorate the New Year tree.
The New Year tree is an undirected tree with n vertices and root in the vertex 1.
You should process the queries of the two types:
1. Change the colours of all vertices in the subtree of the vertex v to the colour c.
2. Find the number of different colours in the subtree of the vertex v.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 4·105) — the number of vertices in the tree and the number of the queries.
The second line contains n integers ci (1 ≤ ci ≤ 60) — the colour of the i-th vertex.
Each of the next n - 1 lines contains two integers xj, yj (1 ≤ xj, yj ≤ n) — the vertices of the j-th edge. It is guaranteed that you are given correct undirected tree.
The last m lines contains the description of the queries. Each description starts with the integer tk (1 ≤ tk ≤ 2) — the type of the k-th query. For the queries of the first type then follows two integers vk, ck (1 ≤ vk ≤ n, 1 ≤ ck ≤ 60) — the number of the vertex whose subtree will be recoloured with the colour ck. For the queries of the second type then follows integer vk (1 ≤ vk ≤ n) — the number of the vertex for which subtree you should find the number of different colours.
Output
For each query of the second type print the integer a — the number of different colours in the subtree of the vertex given in the query.
Each of the numbers should be printed on a separate line in order of query appearing in the input.
Examples
Input
7 10
1 1 1 1 1 1 1
1 2
1 3
1 4
3 5
3 6
3 7
1 3 2
2 1
1 4 3
2 1
1 2 5
2 1
1 6 4
2 1
2 2
2 3
Output
2
3
4
5
1
2
Input
23 30
1 2 2 6 5 3 2 1 1 1 2 4 5 3 4 4 3 3 3 3 3 4 6
1 2
1 3
1 4
2 5
2 6
3 7
3 8
4 9
4 10
4 11
6 12
6 13
7 14
7 15
7 16
8 17
8 18
10 19
10 20
10 21
11 22
11 23
2 1
2 5
2 6
2 7
2 8
2 9
2 10
2 11
2 4
1 12 1
1 13 1
1 14 1
1 15 1
1 16 1
1 17 1
1 18 1
1 19 1
1 20 1
1 21 1
1 22 1
1 23 1
2 1
2 5
2 6
2 7
2 8
2 9
2 10
2 11
2 4
Output
6
1
3
3
2
1
2
3
5
5
1
2
2
1
1
1
2
3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <class T>
void dbs(string str, T t) {
cerr << str << " : " << t << "\n";
}
template <class T, class... S>
void dbs(string str, T t, S... s) {
int idx = str.find(',');
cerr << str.substr(0, idx) << " : " << t << ",";
dbs(str.substr(idx + 1), s...);
}
template <class S, class T>
ostream& operator<<(ostream& os, const pair<S, T>& p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class T>
ostream& operator<<(ostream& os, const set<T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class S, class T>
ostream& operator<<(ostream& os, const map<S, T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class T>
void prc(T a, T b) {
cerr << "[";
for (T i = a; i != b; ++i) {
if (i != a) cerr << ", ";
cerr << *i;
}
cerr << "]\n";
}
const int N = 400010;
vector<int> Adj[N + 1];
long long colorVal[4 * N + 1];
int dfs_timer = 1;
int begin1[N + 1];
int size1[N + 1];
int initColor[N + 1];
class SegTree {
public:
vector<long long> colors;
vector<bool> lazyp;
vector<long long> lazyColor;
SegTree(int n) {
colors.resize(4 * n + 1);
lazyp.resize(4 * n + 1);
lazyColor.resize(4 * n + 1);
build(1, 1, n);
}
void build(int node, int b, int e) {
if (b > e) return;
if (b == e) {
colors[node] = 0, lazyColor[node] = 0, lazyp[node] = false;
return;
}
build(2 * node, b, (b + e) / 2);
build(2 * node + 1, (b + e) / 2 + 1, e);
}
void push(int node, int b, int e) {
if (lazyColor[node] == 0) return;
colors[node] = 0;
colors[node] |= (1LL << lazyColor[node]);
if (b != e) {
lazyColor[2 * node] = lazyColor[node];
lazyColor[2 * node + 1] = lazyColor[node];
}
lazyColor[node] = 0;
}
void update(int node, int b, int e, int i, int j, int color) {
push(node, b, e);
if (b > e || i > e || j < b) return;
if (i <= b and e <= j) {
lazyColor[node] = color;
push(node, b, e);
return;
}
update(2 * node, b, (b + e) / 2, i, j, color);
update(2 * node + 1, (b + e) / 2 + 1, e, i, j, color);
colors[node] = (colors[2 * node] | colors[2 * node + 1]);
return;
}
long long query(int node, int b, int e, int i, int j) {
push(node, b, e);
if (b > e || i > e || j < b) return 0LL;
if (i <= b and e <= j) {
return colors[node];
}
long long colLeft = query(2 * node, b, (b + e) / 2, i, j);
long long colRight = query(2 * node + 1, (b + e) / 2 + 1, e, i, j);
colors[node] = (colors[2 * node] | colors[2 * node + 1]);
long long answers = (colLeft | colRight);
return answers;
}
};
void DFS(int u, int p) {
begin1[u] = dfs_timer++;
size1[u] = 1;
for (auto v : Adj[u]) {
if (v != p) {
DFS(v, u);
size1[u] += size1[v];
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = (int)(1); i <= (int)(n); i++) {
int temp;
cin >> temp;
initColor[i] = temp;
}
SegTree st(n);
for (int i = (int)(1); i <= (int)(n - 1); i++) {
int a1, b1;
cin >> a1 >> b1;
Adj[a1].push_back(b1), Adj[b1].push_back(a1);
}
DFS(1, 0);
for (int i = (int)(1); i <= (int)(n); i++) {
st.update(1, 1, n, begin1[i], begin1[i], initColor[i]);
}
while (m--) {
int tp;
cin >> tp;
if (tp == 1) {
int vk, ck;
cin >> vk >> ck;
st.update(1, 1, n, begin1[vk], begin1[vk] + size1[vk] - 1, ck);
} else {
int vk;
cin >> vk;
long long answer1 =
st.query(1, 1, n, begin1[vk], begin1[vk] + size1[vk] - 1);
cout << __builtin_popcountll(answer1) << "\n";
}
}
return 0;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
Problem
Aizu Magic School is a school where people who can use magic gather. Haruka, one of the students of that school, can use the magic of warp on the magic team.
From her house to the school, there is a straight road of length L. There are also magic circles on this road.
She uses this road every day to go to school, so she wants to get to school in the shortest possible time.
So as a programmer, you decided to teach her the minimum amount of time it would take to get to school.
Haruka can walk forward by a distance of 1 in 1 minute (* cannot go back). Also, by casting magic at the position Pi where the magic circle of the warp is written, you can move in Ti minutes to the place just Di from Pi. Even if there is a magic circle at the destination, it will be continuous. You can use warp magic.
The location of her house is 0 and the location of her school is L.
Constraints
The input meets the following conditions.
* All numbers given are integers
* 1 ≤ L ≤ 109
* 0 ≤ n ≤ min (103, L) (min represents the smaller of A and B)
* 0 ≤ Pi ≤ L -1
* 0 ≤ Di ≤ L --Pi
* 0 ≤ Ti ≤ 103
* Pi ≠ Pj
Input
L n
P1 D1 T1
P2 D2 T2
..
..
Pn Dn Tn
The first line is given the length of the road L, the number of magic circles n. Next, the state of n magic circles is given. Pi is the position where the i-th magic circle is, and Di is the i-th magic circle. Distance to warp from, Ti represents the time it takes to warp using the i-th magic circle.
Output
Output the minimum time to get to school in one line.
Examples
Input
10 3
2 2 1
4 2 1
8 1 1
Output
8
Input
10 2
2 3 1
3 5 1
Output
6
Input
1 0
Output
1
### Response
```cpp
#include "bits/stdc++.h"
#pragma warning(disable:4996)
using namespace std;
using ld = long double;
bool check(string l, string r) {
for (int i = 0; i < l.size(); ++i) {
if (l[i] == r[i] || r[i] == '_') {
}
else {
return false;
}
}
return true;
}
struct warp {
int x;
int d;
int t;
};
bool operator < (const warp&l, const warp&r) {
return l.x<r.x;
}
int main() {
int L,N;cin>>L>>N;
vector<warp>warps;
warps.push_back(warp{ 0,0,0 });
for (int i = 0; i < N; ++i) {
int a,b,c;cin>>a>>b>>c;
warps.push_back(warp{ a,b,c });
}
warps.push_back(warp{ L,0,0 });
sort(warps.begin(),warps.end());
vector<int>costs(N+2,1e9);
costs[0]=0;
for (int k = 0; k < N + 1; ++k) {
const int nx=warps[k].x;
const int nd=warps[k].d;
const int nt=warps[k].t;
auto it = lower_bound(warps.begin(), warps.end(), warp{ nx + nd,0,0 });
const int nextx=it->x;
costs[it-warps.begin()]=min(costs[it - warps.begin()],costs[k]+nt+nextx-(nx+nd));
costs[k+1]=min(costs[k+1],costs[k]+(warps[k+1].x-nx));
}
cout<<costs[N+1]<<endl;
return 0;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
There are infinitely many cards, numbered 1, 2, 3, ... Initially, Cards x_1, x_2, ..., x_N are face up, and the others are face down.
Snuke can perform the following operation repeatedly:
* Select a prime p greater than or equal to 3. Then, select p consecutive cards and flip all of them.
Snuke's objective is to have all the cards face down. Find the minimum number of operations required to achieve the objective.
Constraints
* 1 ≤ N ≤ 100
* 1 ≤ x_1 < x_2 < ... < x_N ≤ 10^7
Input
Input is given from Standard Input in the following format:
N
x_1 x_2 ... x_N
Output
Print the minimum number of operations required to achieve the objective.
Examples
Input
2
4 5
Output
2
Input
9
1 2 3 4 5 6 7 8 9
Output
3
Input
2
1 10000000
Output
4
### Response
```cpp
#include<bits/stdc++.h>
typedef long long ll;
ll gi(){
ll x=0,f=1;
char ch=getchar();
while(!isdigit(ch))f^=ch=='-',ch=getchar();
while(isdigit(ch))x=x*10+ch-'0',ch=getchar();
return f?x:-x;
}
int n,A[101],B[101];
bool yes[10000010];
int pr[670010],P;
int fir[210],dep[210],head[210],dis[3000010],nxt[3000010],w[3000010],id=1,S,T;
void link(int a,int b,int c){
nxt[++id]=fir[a],fir[a]=id,dis[id]=b,w[id]=c;
nxt[++id]=fir[b],fir[b]=id,dis[id]=a,w[id]=0;
}
bool BFS(){
static int que[210],hd,tl;
hd=tl=0;que[tl++]=S;memset(dep,0,sizeof dep);
dep[S]=1;
while(hd^tl){
int x=que[hd++];
for(int i=fir[x];i;i=nxt[i])
if(w[i]&&!dep[dis[i]])dep[dis[i]]=dep[x]+1,que[tl++]=dis[i];
}
return dep[T];
}
int Dinic(int x,int maxflow){
if(x==T)return maxflow;
int ret=0;
for(int&i=head[x];i;i=nxt[i])
if(dep[dis[i]]==dep[x]+1&&w[i]){
int d=Dinic(dis[i],std::min(w[i],maxflow-ret));
w[i]-=d,w[i^1]+=d;ret+=d;if(ret==maxflow)break;
}
return ret;
}
int main(){
n=gi();
for(int i=1;i<=n;++i)A[i]=gi();
std::sort(A+1,A+n+1),n=std::unique(A+1,A+n+1)-A-1;
A[0]=A[n+1]=-1;
int m=0;
for(int i=1;i<=n;++i){
if(A[i]!=A[i-1]+1)B[++m]=A[i]-1;
if(A[i]!=A[i+1]-1)B[++m]=A[i];
}
S=m+1,T=m+2;
int odd=0,even=0;
for(int i=1;i<=m;++i)if(B[i]&1)++odd,link(S,i,1);else++even,link(i,T,1);
for(int i=2;i<=A[n];++i){
if(!yes[i])pr[++P]=i;
for(int j=1;j<=P&&i*pr[j]<=A[n];++j){
yes[i*pr[j]]=1;
if(i%pr[j]==0)break;
}
}
yes[0]=yes[1]=yes[2]=1;
for(int i=1;i<=m;++i)if(B[i]&1)
for(int j=1;j<=m;++j)
if(!yes[abs(B[j]-B[i])])
link(i,j,1);
int ans=0;while(BFS())memcpy(head,fir,sizeof fir),ans+=Dinic(S,1e9);
printf("%d\n",ans+2*((odd-ans>>1)+(even-ans>>1))+3*(odd-ans&1));
return 0;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
Iahub wants to enhance his multitasking abilities. In order to do this, he wants to sort n arrays simultaneously, each array consisting of m integers.
Iahub can choose a pair of distinct indices i and j (1 ≤ i, j ≤ m, i ≠ j). Then in each array the values at positions i and j are swapped only if the value at position i is strictly greater than the value at position j.
Iahub wants to find an array of pairs of distinct indices that, chosen in order, sort all of the n arrays in ascending or descending order (the particular order is given in input). The size of the array can be at most <image> (at most <image> pairs). Help Iahub, find any suitable array.
Input
The first line contains three integers n (1 ≤ n ≤ 1000), m (1 ≤ m ≤ 100) and k. Integer k is 0 if the arrays must be sorted in ascending order, and 1 if the arrays must be sorted in descending order. Each line i of the next n lines contains m integers separated by a space, representing the i-th array. For each element x of the array i, 1 ≤ x ≤ 106 holds.
Output
On the first line of the output print an integer p, the size of the array (p can be at most <image>). Each of the next p lines must contain two distinct integers i and j (1 ≤ i, j ≤ m, i ≠ j), representing the chosen indices.
If there are multiple correct answers, you can print any.
Examples
Input
2 5 0
1 3 2 5 4
1 4 3 2 5
Output
3
2 4
2 3
4 5
Input
3 2 1
1 2
2 3
3 4
Output
1
2 1
Note
Consider the first sample. After the first operation, the arrays become [1, 3, 2, 5, 4] and [1, 2, 3, 4, 5]. After the second operation, the arrays become [1, 2, 3, 5, 4] and [1, 2, 3, 4, 5]. After the third operation they become [1, 2, 3, 4, 5] and [1, 2, 3, 4, 5].
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k, t;
vector<int> v;
vector<vector<int>> vv;
vector<pair<int, int>> p;
cin >> n >> m >> k;
v.assign(m, 0);
p.assign(0, make_pair(0, 0));
vv.assign(n, v);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> vv[i][j];
}
}
if (k == 0) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
for (int l = j + 1; l < m; l++) {
if (vv[i][j] > vv[i][l]) {
t = vv[i][l];
vv[i][l] = vv[i][j];
vv[i][j] = t;
p.push_back(make_pair(j + 1, l + 1));
for (int r = i + 1; r < n; r++) {
if (vv[r][j] > vv[r][l]) {
t = vv[r][l];
vv[r][l] = vv[r][j];
vv[r][j] = t;
}
}
}
}
}
}
} else {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
for (int l = j + 1; l < m; l++) {
if (vv[i][j] < vv[i][l]) {
t = vv[i][l];
vv[i][l] = vv[i][j];
vv[i][j] = t;
p.push_back(make_pair(l + 1, j + 1));
for (int r = i + 1; r < n; r++) {
if (vv[r][j] < vv[r][l]) {
t = vv[r][l];
vv[r][l] = vv[r][j];
vv[r][j] = t;
}
}
}
}
}
}
}
cout << p.size() << endl;
for (int i = 0; i < p.size(); i++) {
cout << p[i].first << ' ' << p[i].second << endl;
}
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
An atom of element X can exist in n distinct states with energies E1 < E2 < ... < En. Arkady wants to build a laser on this element, using a three-level scheme. Here is a simplified description of the scheme.
Three distinct states i, j and k are selected, where i < j < k. After that the following process happens:
1. initially the atom is in the state i,
2. we spend Ek - Ei energy to put the atom in the state k,
3. the atom emits a photon with useful energy Ek - Ej and changes its state to the state j,
4. the atom spontaneously changes its state to the state i, losing energy Ej - Ei,
5. the process repeats from step 1.
Let's define the energy conversion efficiency as <image>, i. e. the ration between the useful energy of the photon and spent energy.
Due to some limitations, Arkady can only choose such three states that Ek - Ei ≤ U.
Help Arkady to find such the maximum possible energy conversion efficiency within the above constraints.
Input
The first line contains two integers n and U (3 ≤ n ≤ 105, 1 ≤ U ≤ 109) — the number of states and the maximum possible difference between Ek and Ei.
The second line contains a sequence of integers E1, E2, ..., En (1 ≤ E1 < E2... < En ≤ 109). It is guaranteed that all Ei are given in increasing order.
Output
If it is not possible to choose three states that satisfy all constraints, print -1.
Otherwise, print one real number η — the maximum possible energy conversion efficiency. Your answer is considered correct its absolute or relative error does not exceed 10 - 9.
Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if <image>.
Examples
Input
4 4
1 3 5 7
Output
0.5
Input
10 8
10 13 15 16 17 19 20 22 24 25
Output
0.875
Input
3 1
2 5 10
Output
-1
Note
In the first example choose states 1, 2 and 3, so that the energy conversion efficiency becomes equal to <image>.
In the second example choose states 4, 5 and 9, so that the energy conversion efficiency becomes equal to <image>.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
cout << setprecision(17);
int n;
long long a[200000];
long long u;
cin >> n >> u;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
a[n] = 10000000000000;
long double ans = -1;
for (int i = 0; i < n - 2; i++) {
int i0 = i;
int i1;
int i2 = n - 1;
int mid = (i + n - 1) / 2;
while (i2 - i0 > 1) {
if (a[mid] > a[i] + u) {
i2 = mid;
mid = (i0 + mid) / 2;
} else {
i0 = mid;
mid = (mid + i2) / 2;
}
}
if (a[i0] <= a[i] + u && a[i0 + 1] > a[i] + u) {
i1 = i0;
}
if (a[i2] <= a[i] + u && a[i2 + 1] > a[i] + u) {
i1 = i2;
}
if (a[i0 - 1] <= a[i] + u && a[i0] > a[i] + u) {
i1 = i0 - 1;
}
if (i1 > i + 1) {
if (ans < (1.0 * (a[i1] - a[i + 1])) / (1.0 * (a[i1] - a[i]))) {
ans = (1.0 * (a[i1] - a[i + 1])) / (1.0 * (a[i1] - a[i]));
}
}
}
if (ans < -0.5) {
cout << "-1";
} else {
cout << ans;
}
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
There are two sequences of colorful stones. The color of each stone is one of red, green, or blue. You are given two strings s and t. The i-th (1-based) character of s represents the color of the i-th stone of the first sequence. Similarly, the i-th (1-based) character of t represents the color of the i-th stone of the second sequence. If the character is "R", "G", or "B", the color of the corresponding stone is red, green, or blue, respectively.
Initially Squirrel Liss is standing on the first stone of the first sequence and Cat Vasya is standing on the first stone of the second sequence. You can perform the following instructions zero or more times.
Each instruction is one of the three types: "RED", "GREEN", or "BLUE". After an instruction c, the animals standing on stones whose colors are c will move one stone forward. For example, if you perform an instruction «RED», the animals standing on red stones will move one stone forward. You are not allowed to perform instructions that lead some animals out of the sequences. In other words, if some animals are standing on the last stones, you can't perform the instructions of the colors of those stones.
A pair of positions (position of Liss, position of Vasya) is called a state. A state is called reachable if the state is reachable by performing instructions zero or more times from the initial state (1, 1). Calculate the number of distinct reachable states.
Input
The input contains two lines. The first line contains the string s (1 ≤ |s| ≤ 106). The second line contains the string t (1 ≤ |t| ≤ 106). The characters of each string will be one of "R", "G", or "B".
Output
Print the number of distinct reachable states in a single line.
Please, do not write the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
RBR
RGG
Output
5
Input
RGBB
BRRBRR
Output
19
Input
RRRRRRRRRR
RRRRRRRR
Output
8
Note
In the first example, there are five reachable states: (1, 1), (2, 2), (2, 3), (3, 2), and (3, 3). For example, the state (3, 3) is reachable because if you perform instructions "RED", "GREEN", and "BLUE" in this order from the initial state, the state will be (3, 3). The following picture shows how the instructions work in this case.
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long sum[3][3][2100010];
long long a[2000100], b[2001000];
char s[2000100];
long long cti(char x) {
if (x == 'R') return 0;
if (x == 'G') return 1;
if (x == 'B') return 2;
}
signed main() {
scanf("%s", s + 1);
long long n = strlen(s + 1);
for (long long i = 1; i <= n; ++i) a[i] = cti(s[i]);
scanf("%s", s + 1);
long long m = strlen(s + 1);
for (long long i = 1; i <= m; ++i) b[i] = cti(s[i]);
for (long long i = 0; i <= 2; ++i)
for (long long j = 0; j <= 2; ++j) {
for (long long k = 1; k <= m; ++k) {
if (b[k - 1] == i && b[k] == j) sum[i][j][k] = 1;
sum[i][j][k] += sum[i][j][k - 1];
}
}
long long l = 1, r = 1;
while (r < m && b[r] != a[1]) r++;
long long ans = r - l + 1;
for (long long i = 2; i <= n; ++i) {
if (l <= m && a[i - 1] == b[l]) l++;
if (l > m) break;
if (r < m) {
r++;
while (r < m && b[r] != a[i]) r++;
}
ans += r - l + 1;
if (a[i] != a[i - 1])
ans -= sum[a[i]][a[i - 1]][r] - sum[a[i]][a[i - 1]][l - 1];
}
printf("%lld", ans);
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
Pari wants to buy an expensive chocolate from Arya. She has n coins, the value of the i-th coin is ci. The price of the chocolate is k, so Pari will take a subset of her coins with sum equal to k and give it to Arya.
Looking at her coins, a question came to her mind: after giving the coins to Arya, what values does Arya can make with them? She is jealous and she doesn't want Arya to make a lot of values. So she wants to know all the values x, such that Arya will be able to make x using some subset of coins with the sum k.
Formally, Pari wants to know the values x such that there exists a subset of coins with the sum k such that some subset of this subset has the sum x, i.e. there is exists some way to pay for the chocolate, such that Arya will be able to make the sum x using these coins.
Input
The first line contains two integers n and k (1 ≤ n, k ≤ 500) — the number of coins and the price of the chocolate, respectively.
Next line will contain n integers c1, c2, ..., cn (1 ≤ ci ≤ 500) — the values of Pari's coins.
It's guaranteed that one can make value k using these coins.
Output
First line of the output must contain a single integer q— the number of suitable values x. Then print q integers in ascending order — the values that Arya can make for some subset of coins of Pari that pays for the chocolate.
Examples
Input
6 18
5 6 1 10 12 2
Output
16
0 1 2 3 5 6 7 8 10 11 12 13 15 16 17 18
Input
3 50
25 25 50
Output
3
0 25 50
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
const int MO = 1e9 + 7;
const int MAXN = 500 + 5;
template <class T>
inline bool ChKKmin(T &x, T y) {
return x > y ? x = y, true : false;
}
template <class T>
inline bool ChKKmax(T &x, T y) {
return x < y ? x = y, true : false;
}
template <class T>
inline T read(T &x) {
static int f;
static char c;
for (f = 1; !isdigit(c = getchar());)
if (c == '-') f = -1;
for (x = 0; isdigit(c); c = getchar()) x = x * 10 + c - 48;
return x *= f;
}
template <class T>
inline void write(T x, char P = '\n') {
static char s[20];
static int top = 0;
if (x < 0) x = -x, putchar('-');
do {
s[++top] = x % 10;
} while (x /= 10);
do {
putchar(s[top] + 48);
} while (--top);
putchar(P);
}
inline void open() {
freopen(".in", "r", stdin);
freopen(".out", "w", stdout);
}
int n, KK;
bool f[MAXN][MAXN], dp[MAXN];
int main() {
f[0][0] = 1;
read(n), read(KK);
for (int i = 1, x; i <= n; ++i) {
read(x);
for (int j = KK; j >= 0; j--)
for (int l = KK; l >= 0; l--)
if ((j >= x && f[j - x][l]) || (l >= x && f[j][l - x])) f[j][l] = 1;
}
for (int i = 0; i <= KK; ++i)
if (f[i][KK - i]) dp[i] = dp[KK - i] = 1;
int tot = 0;
for (int i = 0; i <= KK; ++i) tot += dp[i];
cout << tot << endl;
for (int i = 0; i <= KK; ++i)
if (dp[i]) write(i, ' ');
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
You are given an array consisting of n integers a_1, a_2, ..., a_n, and a positive integer m. It is guaranteed that m is a divisor of n.
In a single move, you can choose any position i between 1 and n and increase a_i by 1.
Let's calculate c_r (0 ≤ r ≤ m-1) — the number of elements having remainder r when divided by m. In other words, for each remainder, let's find the number of corresponding elements in a with that remainder.
Your task is to change the array in such a way that c_0 = c_1 = ... = c_{m-1} = n/m.
Find the minimum number of moves to satisfy the above requirement.
Input
The first line of input contains two integers n and m (1 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ n). It is guaranteed that m is a divisor of n.
The second line of input contains n integers a_1, a_2, ..., a_n (0 ≤ a_i ≤ 10^9), the elements of the array.
Output
In the first line, print a single integer — the minimum number of moves required to satisfy the following condition: for each remainder from 0 to m - 1, the number of elements of the array having this remainder equals n/m.
In the second line, print any array satisfying the condition and can be obtained from the given array with the minimum number of moves. The values of the elements of the resulting array must not exceed 10^{18}.
Examples
Input
6 3
3 2 0 6 10 12
Output
3
3 2 0 7 10 14
Input
4 2
0 1 2 3
Output
0
0 1 2 3
### Response
```cpp
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const double pi = 3.141592653589793;
template <class T>
using V = vector<T>;
using P = pair<long long, long long>;
template <class T>
inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T>
inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T>
inline void out(T a) {
cout << a << '\n';
}
void YN(bool ok) {
if (ok)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
const long long INF = 1e18;
const int mx = 200005;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
V<long long> cnt(m, 0);
V<long long> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
cnt[a[i] % m]++;
}
priority_queue<long long, V<long long>, greater<long long>> que;
V<V<int>> vec(m);
long long ans = 0;
for (int i = 0; i < 2 * m; i++) {
if (cnt[i % m] < n / m) {
while (que.size() && cnt[i % m] < n / m) {
long long from = que.top();
que.pop();
long long cost = i % m - from;
if (cost < 0) cost = cost + m;
ans = ans + cost;
vec[from].push_back(i % m);
cnt[i % m]++;
}
} else if (cnt[i % m] > n / m) {
while (cnt[i % m] > n / m) {
que.push(i % m);
cnt[i % m]--;
}
}
}
cout << ans << endl;
for (int i = 0; i < n; i++) {
if (vec[a[i] % m].size()) {
long long cost = vec[a[i] % m].back() - a[i] % m;
if (cost < 0) cost += m;
vec[a[i] % m].pop_back();
a[i] += cost;
}
cout << a[i] << ' ';
}
cout << endl;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
Zxr960115 is owner of a large farm. He feeds m cute cats and employs p feeders. There's a straight road across the farm and n hills along the road, numbered from 1 to n from left to right. The distance between hill i and (i - 1) is di meters. The feeders live in hill 1.
One day, the cats went out to play. Cat i went on a trip to hill hi, finished its trip at time ti, and then waited at hill hi for a feeder. The feeders must take all the cats. Each feeder goes straightly from hill 1 to n without waiting at a hill and takes all the waiting cats at each hill away. Feeders walk at a speed of 1 meter per unit time and are strong enough to take as many cats as they want.
For example, suppose we have two hills (d2 = 1) and one cat that finished its trip at time 3 at hill 2 (h1 = 2). Then if the feeder leaves hill 1 at time 2 or at time 3, he can take this cat, but if he leaves hill 1 at time 1 he can't take it. If the feeder leaves hill 1 at time 2, the cat waits him for 0 time units, if the feeder leaves hill 1 at time 3, the cat waits him for 1 time units.
Your task is to schedule the time leaving from hill 1 for each feeder so that the sum of the waiting time of all cats is minimized.
Input
The first line of the input contains three integers n, m, p (2 ≤ n ≤ 105, 1 ≤ m ≤ 105, 1 ≤ p ≤ 100).
The second line contains n - 1 positive integers d2, d3, ..., dn (1 ≤ di < 104).
Each of the next m lines contains two integers hi and ti (1 ≤ hi ≤ n, 0 ≤ ti ≤ 109).
Output
Output an integer, the minimum sum of waiting time of all cats.
Please, do not write the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
4 6 2
1 3 5
1 0
2 1
4 9
1 10
2 10
3 12
Output
3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long N = 200005;
long long l, r, n, m, p, x, y, a[N], d[N], q[N], g[N], s[N], f[105][N];
signed main() {
scanf("%lld%lld%lld", &n, &m, &p);
for (long long i = 2; i <= n; i++) {
scanf("%lld", &x);
d[i] = d[i - 1] + x;
}
for (long long i = 1; i <= m; i++) {
scanf("%lld%lld", &x, &y);
a[i] = y - d[x];
}
sort(a + 1, a + m + 1);
for (long long i = 1; i <= m; i++) s[i] = s[i - 1] + a[i];
memset(f, 0x3f, sizeof(f));
f[0][0] = 0;
for (long long i = 1; i <= p; i++) {
for (long long j = 1; j <= m; j++) g[j] = f[i - 1][j] + s[j];
l = r = 1;
q[1] = 0;
for (long long j = 1; j <= m; j++) {
while (l < r && (g[q[l + 1]] - g[q[l]]) <= a[j] * (q[l + 1] - q[l])) l++;
f[i][j] = min(f[i - 1][j], g[q[l]] + a[j] * j - s[j] - a[j] * q[l]);
if (g[j] >= 0x3f3f3f3f3f3f3f3fll) continue;
while (l < r && (g[q[r]] - g[q[r - 1]]) * (j - q[r]) >=
(g[j] - g[q[r]]) * (q[r] - q[r - 1]))
r--;
q[++r] = j;
}
}
cout << f[p][m];
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
Vasya studies positional numeral systems. Unfortunately, he often forgets to write the base of notation in which the expression is written. Once he saw a note in his notebook saying a + b = ?, and that the base of the positional notation wasn’t written anywhere. Now Vasya has to choose a base p and regard the expression as written in the base p positional notation. Vasya understood that he can get different results with different bases, and some bases are even invalid. For example, expression 78 + 87 in the base 16 positional notation is equal to FF16, in the base 15 positional notation it is equal to 11015, in the base 10 one — to 16510, in the base 9 one — to 1769, and in the base 8 or lesser-based positional notations the expression is invalid as all the numbers should be strictly less than the positional notation base. Vasya got interested in what is the length of the longest possible expression value. Help him to find this length.
The length of a number should be understood as the number of numeric characters in it. For example, the length of the longest answer for 78 + 87 = ? is 3. It is calculated like that in the base 15 (11015), base 10 (16510), base 9 (1769) positional notations, for example, and in some other ones.
Input
The first letter contains two space-separated numbers a and b (1 ≤ a, b ≤ 1000) which represent the given summands.
Output
Print a single number — the length of the longest answer.
Examples
Input
78 87
Output
3
Input
1 1
Output
2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b, c;
cin >> a >> b;
c = a + b;
int Max = 0, A = 0, B = 0, sum, system;
for (int i = 0; i < c.length(); ++i) {
if (static_cast<int>(c[i]) - static_cast<int>('0') > Max)
Max = static_cast<int>(c[i]) - static_cast<int>('0');
}
system = Max + 1;
vector<int> x;
vector<int> y;
int p = 0;
for (int i = a.length() - 1; i >= 0; --i) {
x.push_back((static_cast<int>(a[i]) - static_cast<int>('0')) *
pow(system, p));
A = A + x[p];
++p;
}
p = 0;
for (int i = b.length() - 1; i >= 0; --i) {
y.push_back((static_cast<int>(b[i]) - static_cast<int>('0')) *
pow(system, p));
B = B + y[p];
++p;
}
sum = A + B;
vector<int> v;
for (;;) {
v.push_back(sum % system);
if (sum % system == sum) break;
sum = sum / system;
}
cout << v.size();
}
``` |
### Prompt
Generate a cpp solution to the following problem:
Ivan unexpectedly saw a present from one of his previous birthdays. It is array of n numbers from 1 to 200. Array is old and some numbers are hard to read. Ivan remembers that for all elements at least one of its neighbours ls not less than it, more formally:
a_{1} ≤ a_{2},
a_{n} ≤ a_{n-1} and
a_{i} ≤ max(a_{i-1}, a_{i+1}) for all i from 2 to n-1.
Ivan does not remember the array and asks to find the number of ways to restore it. Restored elements also should be integers from 1 to 200. Since the number of ways can be big, print it modulo 998244353.
Input
First line of input contains one integer n (2 ≤ n ≤ 10^{5}) — size of the array.
Second line of input contains n integers a_{i} — elements of array. Either a_{i} = -1 or 1 ≤ a_{i} ≤ 200. a_{i} = -1 means that i-th element can't be read.
Output
Print number of ways to restore the array modulo 998244353.
Examples
Input
3
1 -1 2
Output
1
Input
2
-1 -1
Output
200
Note
In the first example, only possible value of a_{2} is 2.
In the second example, a_{1} = a_{2} so there are 200 different values because all restored elements should be integers between 1 and 200.
### Response
```cpp
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx")
using namespace std;
bool is_prime(long long n) {
if (n <= 1) {
return false;
}
for (long long i = 2; i * i <= n; ++i) {
if (n % i == 0) {
return false;
}
}
return true;
}
inline long long getPow(long long a, long long b) {
long long res = 1ll, tp = a;
while (b) {
if (b & 1ll) {
res *= tp;
}
tp *= tp;
b >>= 1ll;
}
return res;
}
long long coso(long long x1, long long y1, long long x2, long long y2,
long long x3, long long y3) {
return abs((x2 - x1) * (y3 - y1) - (y2 - y1) * (x3 - x1));
}
inline long long nxt() {
long long x;
cin >> x;
return x;
}
void ok() {
puts("YES");
exit(0);
}
void no() {
puts("NO");
exit(0);
}
const long long N = 1e6 + 5;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n = nxt();
vector<long long> mas(n);
for (int i = 0; i < n; i++) {
mas[i] = nxt();
}
vector<vector<long long>> dp(200 + 5, vector<long long>(2, 0LL));
if (mas[0] == -1) {
for (int i = 1; i <= 200; i++) {
dp[i][1] = 1;
}
} else
dp[mas[0]][1] = 1;
for (int i = 1; i < n; i++) {
long long cur = 0;
vector<vector<long long>> dp2(200 + 5, vector<long long>(2, 0LL));
for (int j = 1; j <= 200; j++) {
dp2[j][1] = cur;
cur = (cur + dp[j][0] + dp[j][1]);
while (cur > 998244353) {
cur -= 998244353;
}
}
cur = 0;
for (int j = 200; j >= 1; j--) {
dp2[j][0] =
((dp2[j][0] + dp[j][0] + dp[j][1]) % 998244353 + cur) % 998244353;
while (dp2[j][0] > 998244353) {
dp2[j][0] -= 998244353;
}
cur = (cur + dp[j][0]);
while (cur > 998244353) {
cur -= 998244353;
}
}
for (int j = 1; j <= 200; j++) {
if (mas[i] != -1 && mas[i] != j) {
dp2[j][0] = dp2[j][1] = 0;
}
}
dp = dp2;
}
long long ans = 0LL;
for (int i = 1; i <= 200; i++) {
ans += dp[i][0];
}
cout << ans % 998244353;
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
Programmer Vasya is studying a new programming language &K*. The &K* language resembles the languages of the C family in its syntax. However, it is more powerful, which is why the rules of the actual C-like languages are unapplicable to it. To fully understand the statement, please read the language's description below carefully and follow it and not the similar rules in real programming languages.
There is a very powerful system of pointers on &K* — you can add an asterisk to the right of the existing type X — that will result in new type X * . That is called pointer-definition operation. Also, there is the operation that does the opposite — to any type of X, which is a pointer, you can add an ampersand — that will result in a type &X, to which refers X. That is called a dereference operation.
The &K* language has only two basic data types — void and errtype. Also, the language has operators typedef and typeof.
* The operator "typedef A B" defines a new data type B, which is equivalent to A. A can have asterisks and ampersands, and B cannot have them. For example, the operator typedef void** ptptvoid will create a new type ptptvoid, that can be used as void**.
* The operator "typeof A" returns type of A, brought to void, that is, returns the type void**...*, equivalent to it with the necessary number of asterisks (the number can possibly be zero). That is, having defined the ptptvoid type, as shown above, the typeof ptptvoid operator will return void**.
An attempt of dereferencing of the void type will lead to an error: to a special data type errtype. For errtype the following equation holds true: errtype* = &errtype = errtype. An attempt to use the data type that hasn't been defined before that will also lead to the errtype.
Using typedef, we can define one type several times. Of all the definitions only the last one is valid. However, all the types that have been defined earlier using this type do not change.
Let us also note that the dereference operation has the lower priority that the pointer operation, in other words &T * is always equal to T.
Note, that the operators are executed consecutively one by one. If we have two operators "typedef &void a" and "typedef a* b", then at first a becomes errtype, and after that b becomes errtype* = errtype, but not &void* = void (see sample 2).
Vasya does not yet fully understand this powerful technology, that's why he asked you to help him. Write a program that analyzes these operators.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the number of operators. Then follow n lines with operators. Each operator is of one of two types: either "typedef A B", or "typeof A". In the first case the B type differs from void and errtype types, and besides, doesn't have any asterisks and ampersands.
All the data type names are non-empty lines of no more than 20 lowercase Latin letters. The number of asterisks and ampersands separately in one type in any operator does not exceed 10, however if we bring some types to void with several asterisks, their number may exceed 10.
Output
For every typeof operator print on the single line the answer to that operator — the type that the given operator returned.
Examples
Input
5
typedef void* ptv
typeof ptv
typedef &&ptv node
typeof node
typeof &ptv
Output
void*
errtype
void
Input
17
typedef void* b
typedef b* c
typeof b
typeof c
typedef &b b
typeof b
typeof c
typedef &&b* c
typeof c
typedef &b* c
typeof c
typedef &void b
typeof b
typedef b******* c
typeof c
typedef &&b* c
typeof c
Output
void*
void**
void
void**
errtype
void
errtype
errtype
errtype
Note
Let's look at the second sample.
After the first two queries typedef the b type is equivalent to void*, and с — to void**.
The next query typedef redefines b — it is now equal to &b = &void* = void. At that, the с type doesn't change.
After that the с type is defined as &&b* = &&void* = &void = errtype. It doesn't influence the b type, that's why the next typedef defines c as &void* = void.
Then the b type is again redefined as &void = errtype.
Please note that the c type in the next query is defined exactly as errtype******* = errtype, and not &void******* = void******. The same happens in the last typedef.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d\n", &n);
string s;
map<string, pair<int, int>> m;
m["void"] = make_pair(1, 0);
for (int i = 0; i < n; i++) {
getline(cin, s);
if (s.substr(0, 6) == "typeof") {
s = s.substr(7, s.size() - 7);
int p = 0;
while (s[s.size() - 1] == '*') {
p++;
s = s.substr(0, s.size() - 1);
}
while (s[0] == '&') {
p--;
s = s.substr(1, s.size() - 1);
}
if (m[s].first != 0 && m[s].second + p >= 0) {
cout << "void";
for (int j = 0; j < m[s].second + p; j++) cout << "*";
cout << endl;
} else
cout << "errtype" << endl;
} else {
s = s.substr(8, s.size() - 8);
string t, g;
t = s.substr(0, s.find(' '));
g = s.substr(t.size() + 1, s.size() - t.size() - 1);
s = t;
int p = 0;
while (s[s.size() - 1] == '*') {
p++;
s = s.substr(0, s.size() - 1);
}
while (s[0] == '&') {
p--;
s = s.substr(1, s.size() - 1);
}
pair<int, int> h = m[s];
if (h.first != 0 && p + h.second >= 0)
m[g] = make_pair(1, p + h.second);
else
m[g] = make_pair(0, 0);
}
}
}
``` |
### Prompt
Create a solution in CPP for the following problem:
The sequence of integer pairs (a1, b1), (a2, b2), ..., (ak, bk) is beautiful, if the following statements are fulfilled:
* 1 ≤ a1 ≤ b1 < a2 ≤ b2 < ... < ak ≤ bk ≤ n, where n is a given positive integer;
* all numbers b1 - a1, b2 - a2, ..., bk - ak are distinct.
For the given number n find the number of beautiful sequences of length k. As the answer can be rather large, print the remainder after dividing it by 1000000007 (109 + 7).
Input
The first line contains integer t (1 ≤ t ≤ 2·105) — the number of the test data.
Each of the next t lines contains two integers n and k (1 ≤ k ≤ n ≤ 1000).
Output
For each test from the input print the answer to the problem modulo 1000000007 (109 + 7). Print the answers to the tests in the order in which the tests are given in the input.
Examples
Input
6
1 1
2 1
2 2
3 1
3 2
3 3
Output
1
3
0
6
2
0
Note
In the first test sample there is exactly one beautiful sequence: (1, 1).
In the second test sample, the following sequences are beautiful:
* (1, 1);
* (1, 2);
* (2, 2).
In the fourth test sample, the following sequences are beautiful:
* (1, 1);
* (1, 2);
* (1, 3);
* (2, 2);
* (2, 3);
* (3, 3).
In the fifth test sample, the following sequences are beautiful:
* (1, 1), (2, 3);
* (1, 2), (3, 3).
In the third and sixth samples, there are no beautiful sequences.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long s[1005][1005];
long long fact[1005];
long long invfact[1005];
long long choose[1005][1005];
long long s1(int x, int y) {
if (y < 0) return 0;
return s[x][y];
}
long long sum(int k, int n) {
long long sum1 = 0;
for (int i = 0; i <= n; ++i) {
sum1 = (sum1 + choose[n - i][k] * s1(k, i));
if (sum1 > 5E17) sum1 %= 1000000007;
}
return sum1;
}
int main() {
fact[0] = 1;
for (int i = 1; i <= 1000; ++i) fact[i] = (i * fact[i - 1]) % 1000000007;
invfact[0] = 1;
for (long long i = 1; i <= 1000; ++i) {
long long l = 1;
while (l % i != 0) l += 1000000007;
l /= i;
invfact[i] = (l * invfact[i - 1]) % 1000000007;
}
s[0][0] = 1;
for (int i = 1; i <= 1000; ++i) s[0][i] = 0;
for (int i = 1; i <= 1000; ++i) {
for (int j = 0; j <= 1000; ++j) {
s[i][j] = (i * s1(i - 1, j - i + 1) + s1(i, j - i)) % 1000000007;
}
}
for (int i = 0; i <= 1000; ++i)
for (int j = 0; j <= 1000; ++j) {
if (i < j) {
choose[i][j] = 0;
continue;
}
choose[i][j] =
((fact[i] * invfact[i - j]) % 1000000007 * invfact[j]) % 1000000007;
}
int t;
cin >> t;
for (int i = 0; i < t; ++i) {
int k, n;
cin >> n >> k;
printf("%d\n", sum(k, n) % 1000000007);
}
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
The mayor of Amida, the City of Miracle, is not elected like any other city. Once exhausted by long political struggles and catastrophes, the city has decided to leave the fate of all candidates to the lottery in order to choose all candidates fairly and to make those born under the lucky star the mayor. I did. It is a lottery later called Amidakuji.
The election is held as follows. The same number of long vertical lines as the number of candidates will be drawn, and some horizontal lines will be drawn there. Horizontal lines are drawn so as to connect the middle of adjacent vertical lines. Below one of the vertical lines is written "Winning". Which vertical line is the winner is hidden from the candidates. Each candidate selects one vertical line. Once all candidates have been selected, each candidate follows the line from top to bottom. However, if a horizontal line is found during the movement, it moves to the vertical line on the opposite side to which the horizontal line is connected, and then traces downward. When you reach the bottom of the vertical line, the person who says "winning" will be elected and become the next mayor.
This method worked. Under the lucky mayor, a peaceful era with few conflicts and disasters continued. However, in recent years, due to population growth, the limits of this method have become apparent. As the number of candidates increased, the Amidakuji became large-scale, and manual tabulation took a lot of time. Therefore, the city asked you, the programmer of the city hall, to computerize the Midakuji.
Your job is to write a program that finds the structure of the Amidakuji and which vertical line you will eventually reach given the position of the selected vertical line.
The figure below shows the contents of the input and output given as a sample.
<image>
Input
The input consists of multiple datasets. One dataset is given as follows.
> n m a
> Horizontal line 1
> Horizontal line 2
> Horizontal line 3
> ...
> Horizontal line m
>
n, m, and a are integers that satisfy 2 <= n <= 100, 0 <= m <= 1000, 1 <= a <= n, respectively. Represents a number.
The horizontal line data is given as follows.
> h p q
h, p, and q are integers that satisfy 1 <= h <= 1000, 1 <= p <q <= n, respectively, h is the height of the horizontal line, and p and q are connected to the horizontal line 2 Represents the number of the vertical line of the book.
No two or more different horizontal lines are attached to the same height of one vertical line.
At the end of the input, there is a line consisting of only three zeros separated by blanks.
Output
Output one line for each dataset, the number of the vertical line at the bottom of the vertical line a when traced from the top.
Sample Input
4 4 1
3 1 2
2 2 3
3 3 4
1 3 4
0 0 0
Output for the Sample Input
Four
Example
Input
4 4 1
3 1 2
2 2 3
3 3 4
1 3 4
0 0 0
Output
4
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(){
int n,m,a;
while(cin >> n >> m >> a and !(n==0 && m==0 && a==0)){
vector<vector<int> > ami(1005);
for(int i=0;i<m;i++){
int h,p,q;
cin >> h >> p >> q;
h--, p--, q--;
ami[h].push_back(p);
}
int point = a-1;
for(int i=1004;i>=0;i--){
for(int j=0;j<ami[i].size();j++){
if(point==ami[i][j]){
point = point + 1;
}else if(point-1==ami[i][j]){
point = point - 1;
}
}
}
cout << point+1 << endl;
}
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
Given are two strings S and T.
Let us change some of the characters in S so that T will be a substring of S.
At least how many characters do we need to change?
Here, a substring is a consecutive subsequence. For example, `xxx` is a substring of `yxxxy`, but not a substring of `xxyxx`.
Constraints
* The lengths of S and T are each at least 1 and at most 1000.
* The length of T is at most that of S.
* S and T consist of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
T
Output
Print the minimum number of characters in S that need to be changed.
Examples
Input
cabacc
abc
Output
1
Input
codeforces
atcoder
Output
6
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main()
{
string s,t;
cin>>s>>t;
int ans=1e9;
for(int i=0;i<s.size()-t.size()+1;i++){
int cnt=0;
for(int j=0;j<t.size();j++)
if(s[i+j]!=t[j])
cnt++;
ans=min(ans,cnt);
}
cout<<ans<<endl;
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
Creatnx has n mirrors, numbered from 1 to n. Every day, Creatnx asks exactly one mirror "Am I beautiful?". The i-th mirror will tell Creatnx that he is beautiful with probability (p_i)/(100) for all 1 ≤ i ≤ n.
Some mirrors are called checkpoints. Initially, only the 1st mirror is a checkpoint. It remains a checkpoint all the time.
Creatnx asks the mirrors one by one, starting from the 1-st mirror. Every day, if he asks i-th mirror, there are two possibilities:
* The i-th mirror tells Creatnx that he is beautiful. In this case, if i = n Creatnx will stop and become happy, otherwise he will continue asking the i+1-th mirror next day;
* In the other case, Creatnx will feel upset. The next day, Creatnx will start asking from the checkpoint with a maximal number that is less or equal to i.
There are some changes occur over time: some mirrors become new checkpoints and some mirrors are no longer checkpoints. You are given q queries, each query is represented by an integer u: If the u-th mirror isn't a checkpoint then we set it as a checkpoint. Otherwise, the u-th mirror is no longer a checkpoint.
After each query, you need to calculate [the expected number](https://en.wikipedia.org/wiki/Expected_value) of days until Creatnx becomes happy.
Each of this numbers should be found by modulo 998244353. Formally, let M = 998244353. It can be shown that the answer can be expressed as an irreducible fraction p/q, where p and q are integers and q not ≡ 0 \pmod{M}. Output the integer equal to p ⋅ q^{-1} mod M. In other words, output such an integer x that 0 ≤ x < M and x ⋅ q ≡ p \pmod{M}.
Input
The first line contains two integers n, q (2 ≤ n, q ≤ 2 ⋅ 10^5) — the number of mirrors and queries.
The second line contains n integers: p_1, p_2, …, p_n (1 ≤ p_i ≤ 100).
Each of q following lines contains a single integer u (2 ≤ u ≤ n) — next query.
Output
Print q numbers – the answers after each query by modulo 998244353.
Examples
Input
2 2
50 50
2
2
Output
4
6
Input
5 5
10 20 30 40 50
2
3
4
5
3
Output
117
665496274
332748143
831870317
499122211
Note
In the first test after the first query, the first and the second mirrors are checkpoints. Creatnx will ask the first mirror until it will say that he is beautiful, after that he will ask the second mirror until it will say that he is beautiful because the second mirror is a checkpoint. After that, he will become happy. Probabilities that the mirrors will say, that he is beautiful are equal to 1/2. So, the expected number of days, until one mirror will say, that he is beautiful is equal to 2 and the answer will be equal to 4 = 2 + 2.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long MOD = 998244353;
long long fpow(long long base, long long exp) {
long long result = 1;
while (exp) {
if (exp & 1) result = (result * base) % MOD;
exp >>= 1;
base = (base * base) % MOD;
}
return result;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
long long ans = 0;
for (int i = 0, ThxDem = n; i < ThxDem; ++i) {
long long x;
cin >> x;
long long val = 100ll * fpow(x, MOD - 2) % MOD;
ans = (ans + val + (val - 1 + MOD) * ans) % MOD;
}
cout << ans << "\n";
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
Kolya is going to make fresh orange juice. He has n oranges of sizes a1, a2, ..., an. Kolya will put them in the juicer in the fixed order, starting with orange of size a1, then orange of size a2 and so on. To be put in the juicer the orange must have size not exceeding b, so if Kolya sees an orange that is strictly greater he throws it away and continues with the next one.
The juicer has a special section to collect waste. It overflows if Kolya squeezes oranges of the total size strictly greater than d. When it happens Kolya empties the waste section (even if there are no more oranges) and continues to squeeze the juice. How many times will he have to empty the waste section?
Input
The first line of the input contains three integers n, b and d (1 ≤ n ≤ 100 000, 1 ≤ b ≤ d ≤ 1 000 000) — the number of oranges, the maximum size of the orange that fits in the juicer and the value d, which determines the condition when the waste section should be emptied.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 1 000 000) — sizes of the oranges listed in the order Kolya is going to try to put them in the juicer.
Output
Print one integer — the number of times Kolya will have to empty the waste section.
Examples
Input
2 7 10
5 6
Output
1
Input
1 5 10
7
Output
0
Input
3 10 10
5 7 7
Output
1
Input
1 1 1
1
Output
0
Note
In the first sample, Kolya will squeeze the juice from two oranges and empty the waste section afterwards.
In the second sample, the orange won't fit in the juicer so Kolya will have no juice at all.
### Response
```cpp
#include <bits/stdc++.h>
const int INF = 1e9;
using namespace std;
int n, b, d;
int a[100000];
void solve() {
long long sum = 0;
long long count = 0;
for (int i = 0; i < n; i++) {
if (a[i] > b) continue;
sum += a[i];
if (sum > d) {
count++;
sum = 0;
}
}
cout << count;
}
int main() {
scanf("%d%d%d", &n, &b, &d);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
solve();
printf("\n");
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
Write a program which performs the following operations to a binary search tree $T$ by adding the find operation to A: Binary Search Tree I.
* insert $k$: Insert a node containing $k$ as key into $T$.
* find $k$: Report whether $T$ has a node containing $k$.
* print: Print the keys of the binary search tree by inorder tree walk and preorder tree walk respectively.
Constraints
* The number of operations $\leq 500,000$
* The number of print operations $\leq 10$.
* $-2,000,000,000 \leq key \leq 2,000,000,000$
* The height of the binary tree does not exceed 100 if you employ the above pseudo code.
* The keys in the binary search tree are all different.
Input
In the first line, the number of operations $m$ is given. In the following $m$ lines, operations represented by insert $k$, find $k$ or print are given.
Output
For each find $k$ operation, print "yes" if $T$ has a node containing $k$, "no" if not.
In addition, for each print operation, print a list of keys obtained by inorder tree walk and preorder tree walk in a line respectively. Put a space character before each key.
Example
Input
10
insert 30
insert 88
insert 12
insert 1
insert 20
find 12
insert 17
insert 25
find 16
print
Output
yes
no
1 12 17 20 25 30 88
30 12 1 20 17 25 88
### Response
```cpp
#include<cstdio>
#define N 500005
struct mzls
{
int key;
mzls *ch[2];
};
mzls tree[N];
bool f1=1;
mzls *root,*NIL,*ncnt;
inline void Init()
{
NIL=&tree[0];
NIL->ch[0]=NIL->ch[1]=NIL;
ncnt=&tree[1];
root=NIL;
}
inline mzls *newnode(int ml)
{
mzls *p=++ncnt;
p->key=ml;
p->ch[0]=p->ch[1]=NIL;
return p;
}
inline void Insert(mzls *&rt,int ml)
{
if(rt==NIL)
{
rt=newnode(ml);
return;
}
int d=(ml>=rt->key);
Insert(rt->ch[d],ml);
}
inline void InOrder(mzls *rt)
{
if(rt==NIL)
return;
InOrder(rt->ch[0]);
printf(" %d",rt->key);
InOrder(rt->ch[1]);
}
inline void Preorder(mzls *rt)
{
if(rt==NIL)
return;
printf(" %d",rt->key);
Preorder(rt->ch[0]);
Preorder(rt->ch[1]);
}
inline mzls *Find(mzls *rt, int ml)
{
if(rt==NIL) return NIL;
if(rt->key==ml) return rt;
int d=(ml>=rt->key);
return Find(rt->ch[d],ml);
}
int main()
{
int n,x;
char op[100];
Init();
scanf("%d",&n);
for(int i=0;i<n;i++)
{
scanf("%s",op);
if(op[0]=='i')
{
scanf("%d",&x);
Insert(root,x);
}
else if(op[0]=='f')
{
scanf("%d", &x);
mzls *p=Find(root, x);
if(p==NIL)
puts("no");
else
puts("yes");
}
else
{
InOrder(root);
puts("");
Preorder(root);
puts("");
}
}
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
This is an easy version of the problem. In this version, all numbers in the given array are distinct and the constraints on n are less than in the hard version of the problem.
You are given an array a of n integers (there are no equals elements in the array). You can perform the following operations on array elements:
1. choose any index i (1 ≤ i ≤ n) and move the element a[i] to the begin of the array;
2. choose any index i (1 ≤ i ≤ n) and move the element a[i] to the end of the array.
For example, if n = 5, a = [4, 7, 2, 3, 9], then the following sequence of operations can be performed:
* after performing the operation of the first type to the second element, the array a will become [7, 4, 2, 3, 9];
* after performing the operation of the second type to the second element, the array a will become [7, 2, 3, 9, 4].
You can perform operations of any type any number of times in any order.
Find the minimum total number of operations of the first and second type that will make the a array sorted in non-decreasing order. In other words, what is the minimum number of operations that must be performed so the array satisfies the inequalities a[1] ≤ a[2] ≤ … ≤ a[n].
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases in the test. Then t test cases follow.
Each test case starts with a line containing an integer n (1 ≤ n ≤ 3000) — length of the array a.
Then follow n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 10^9) — an array that needs to be sorted by the given operations. All numbers in the given array are distinct.
The sum of n for all test cases in one test does not exceed 3000.
Output
For each test case output one integer — the minimum total number of operations of the first and second type, which will make the array sorted in non-decreasing order.
Example
Input
4
5
4 7 2 3 9
5
3 5 8 1 7
5
1 4 5 7 12
4
0 2 1 3
Output
2
2
0
2
Note
In the first test case, you first need to move 3, and then 2 to the beginning of the array. Therefore, the desired sequence of operations: [4, 7, 2, 3, 9] → [3, 4, 7, 2, 9] → [2, 3, 4, 7, 9].
In the second test case, you need to move the 1 to the beginning of the array, and the 8 — to the end. Therefore, the desired sequence of operations: [3, 5, 8, 1, 7] → [1, 3, 5, 8, 7] → [1, 3, 5, 7, 8].
In the third test case, the array is already sorted.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int read() {
int x, f = 1;
char ch;
while (ch = getchar(), ch < '0' || ch > '9')
if (ch == '-') f = -1;
x = ch - '0';
while (ch = getchar(), ch >= '0' && ch <= '9')
x = (x << 3) + (x << 1) + ch - 48;
return x * f;
}
const int N = 200005;
pair<int, int> a[N];
set<int> s;
int sta[N], top;
int main() {
int i, j, n, m, T, ans;
T = read();
while (T--) {
s.clear();
n = read();
ans = 0;
for (i = 1; i <= n; i++) a[i] = {read(), -i};
sort(a + 1, a + i);
j = 1;
top = 0;
for (i = 1; i <= n; i++) {
if (a[i].first != a[i - top].first) {
while (top) s.insert(sta[top--]);
top = 0;
}
while (s.size() && *s.begin() < a[i].second) {
s.erase(a[j].second);
j++;
}
sta[++top] = a[i].second;
ans = max(ans, top + int(s.size()));
}
printf("%d\n", n - ans);
}
return 0;
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
Rabbits and cats are competing. The rules are as follows.
First, each of the two animals wrote n2 integers on a piece of paper in a square with n rows and n columns, and drew one card at a time. Shuffle two cards and draw them one by one alternately. Each time a card is drawn, the two will mark it if the same number as the card is written on their paper. The winning condition is that the number of "a set of n numbers with a mark and is in a straight line" is equal to or greater than the number of playing cards drawn at the beginning.
Answer which of the rabbit and the cat wins up to the mth card given. However, the victory or defeat is when only one of the two cards meets the victory condition when a certain card is drawn and marked. In other cases, it is a draw. Cards may be drawn even after one of them meets the victory conditions, but this does not affect the victory or defeat.
Input
Line 1: “nuvm” (square size, number of rabbit playing cards, number of cat playing cards, number of cards drawn) 2- (N + 1) Line: n2 numbers that the rabbit writes on paper ( N + 2)-(2N + 1) Line: n2 numbers that the cat writes on paper (2N + 2)-(2N + M + 1) Line: m cards drawn
1 ≤ n ≤ 500
1 ≤ u, v ≤ 13
1 ≤ m ≤ 100 000
1 ≤ (number written) ≤ 1 000 000
The number of n2 rabbits write on paper, the number of n2 cats write on paper, and the number of m cards drawn are different.
Output
Output "USAGI" if the rabbit wins, "NEKO" if the cat wins, and "DRAW" if the tie, each in one line.
Examples
Input
3 2 2 10
1 2 3
4 5 6
7 8 9
1 2 3
6 5 4
7 8 9
11
4
7
5
10
9
2
1
3
8
Output
USAGI
Input
3 2 1 10
1 2 3
4 5 6
7 8 9
1 2 3
6 5 4
7 8 9
11
4
7
5
10
9
2
1
3
8
Output
DRAW
### Response
```cpp
#include"bits/stdc++.h"
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define FOR(k,m,n) for(ll (k)=(m);(k)<(n);(k)++)
#define REP(i,n) FOR((i),0,(n))
#define WAITING(str) int str;std::cin>>str;
#define DEBUGING(str) cout<< #str << " " str<<endl
constexpr int INF = (1 << 30);
constexpr ll INFL = (1ll << 60);
constexpr ll MOD = 1000000007;// 10^9+7
int n, u, v, m;
vector<vector<int>> usa, neko;
vector<int> card;
void paint(vector<vector<int>>& tile, int lim) {
set<int> cand;
REP(i, lim) cand.insert(card[i]);
REP(i, n)REP(j, n) {
int num = tile[i][j];
if (cand.find(num) == cand.end()) {
tile[i][j] = 0;
}
}
}
int judge(vector<vector<int>> tile, int lim) {
paint(tile, lim);
int res = 0;
// ud
REP(i, n) {
REP(j, n)if (tile[i][j] == 0)goto end;
res++;
end:;
}
// lr
REP(j, n) {
REP(i, n)if (tile[i][j] == 0)goto end2;
res++;
end2:;
}
// slash
REP(i, n) if (tile[i][i] == 0)goto end3;
res++;
end3:;
REP(i, n)if (tile[i][n - 1 - i] == 0)goto end4;
res++;
end4:;
return res;
}
void single() {
int uidx = find(card.begin(), card.end(), usa[0][0]) - card.begin();
int nidx = find(card.begin(), card.end(), neko[0][0]) - card.begin();
if (u == 1 && v == 1) {
if (uidx == nidx)cout << "DRAW" << endl;
else cout << (uidx < nidx ? "USAGI" : "NEKO") << endl;
}
else if (u == 1) {
cout << (uidx < m ? "USAGI" : "DRAW") << endl;
}
else if (v == 1) {
cout << (uidx < m ? "NEKO" : "DRAW") << endl;
}
else {
cout << "DRAW" << endl;
}
}
int main()
{
cin >> n >> u >> v >> m;
usa.resize(n, vector<int>(n));
neko.resize(n, vector<int>(n));
card.resize(m);
REP(i, n) REP(j, n)cin >> usa[i][j];
REP(i, n) REP(j, n)cin >> neko[i][j];
REP(i, m)cin >> card[i];
if (n == 1) {
single();
return 0;
}
int l = 0, r = m;
while (r - l > 1) {
int mid = (l + r) / 2;
bool res1 = judge(usa, mid) >= u;
bool res2 = judge(neko, mid) >= v;
if (res1 && res2)r = mid;
else if (!res1 && !res2) l = mid;
else {
cout << (res1 ? "USAGI" : "NEKO") << endl;
return 0;
}
}
bool res1 = judge(usa, r) >= u;
bool res2 = judge(neko, r) >= v;
if (res1 == res2)cout << "DRAW" << endl;
else cout << (res1 ? "USAGI" : "NEKO") << endl;
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
You can perfectly predict the price of a certain stock for the next N days. You would like to profit on this knowledge, but only want to transact one share of stock per day. That is, each day you will either buy one share, sell one share, or do nothing. Initially you own zero shares, and you cannot sell shares when you don't own any. At the end of the N days you would like to again own zero shares, but want to have as much money as possible.
Input
Input begins with an integer N (2 ≤ N ≤ 3·105), the number of days.
Following this is a line with exactly N integers p1, p2, ..., pN (1 ≤ pi ≤ 106). The price of one share of stock on the i-th day is given by pi.
Output
Print the maximum amount of money you can end up with at the end of N days.
Examples
Input
9
10 5 4 7 9 12 6 2 10
Output
20
Input
20
3 1 4 1 5 9 2 6 5 3 5 8 9 7 9 3 2 3 8 4
Output
41
Note
In the first example, buy a share at 5, buy another at 4, sell one at 9 and another at 12. Then buy at 2 and sell at 10. The total profit is - 5 - 4 + 9 + 12 - 2 + 10 = 20.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
multiset<int> mst;
int main() {
int n;
scanf("%d", &n);
long long ans = 0;
for (int i = 0; i < n; i++) {
int v;
scanf("%d", &v);
if (mst.empty() || *mst.begin() > v) {
mst.insert(v);
} else if (*mst.begin() <= v) {
ans += 1ll * (v - *mst.begin());
mst.erase(mst.begin());
mst.insert(v);
mst.insert(v);
}
}
printf("%I64d\n", ans);
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
By the age of three Smart Beaver mastered all arithmetic operations and got this summer homework from the amazed teacher:
You are given a sequence of integers a1, a2, ..., an. Your task is to perform on it m consecutive operations of the following type:
1. For given numbers xi and vi assign value vi to element axi.
2. For given numbers li and ri you've got to calculate sum <image>, where f0 = f1 = 1 and at i ≥ 2: fi = fi - 1 + fi - 2.
3. For a group of three numbers li ri di you should increase value ax by di for all x (li ≤ x ≤ ri).
Smart Beaver planned a tour around great Canadian lakes, so he asked you to help him solve the given problem.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 2·105) — the number of integers in the sequence and the number of operations, correspondingly. The second line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 105). Then follow m lines, each describes an operation. Each line starts with an integer ti (1 ≤ ti ≤ 3) — the operation type:
* if ti = 1, then next follow two integers xi vi (1 ≤ xi ≤ n, 0 ≤ vi ≤ 105);
* if ti = 2, then next follow two integers li ri (1 ≤ li ≤ ri ≤ n);
* if ti = 3, then next follow three integers li ri di (1 ≤ li ≤ ri ≤ n, 0 ≤ di ≤ 105).
The input limits for scoring 30 points are (subproblem E1):
* It is guaranteed that n does not exceed 100, m does not exceed 10000 and there will be no queries of the 3-rd type.
The input limits for scoring 70 points are (subproblems E1+E2):
* It is guaranteed that there will be queries of the 1-st and 2-nd type only.
The input limits for scoring 100 points are (subproblems E1+E2+E3):
* No extra limitations.
Output
For each query print the calculated sum modulo 1000000000 (109).
Examples
Input
5 5
1 3 1 2 4
2 1 4
2 1 5
2 2 4
1 3 10
2 1 5
Output
12
32
8
50
Input
5 4
1 3 1 2 4
3 1 4 1
2 2 4
1 2 10
2 1 5
Output
12
45
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long inf = INT_MAX, df = 2e5 + 7, mod = 1e9;
long long i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a[df], f[df],
sum[df], tag[df];
struct node {
long long sum1, sum2, siz;
} ma[df << 2];
inline long long read() {
long long x = 0, y = 1;
char ch = getchar();
while (ch > '9' || ch < '0') y = (ch == '-') ? -1 : 1, ch = getchar();
while (ch >= '0' && ch <= '9')
x = (x << 3) + (x << 1) + ch - '0', ch = getchar();
return x * y;
}
void pushdown(long long num, long long le, long long rig) {
if (!tag[num]) return;
ma[num].sum1 = ma[num].sum2 = 0;
tag[(num << 1)] += tag[num] % mod, tag[(num << 1)] %= mod,
tag[(num << 1 | 1)] += tag[num] % mod, tag[(num << 1 | 1)] %= mod;
if (ma[(num << 1)].siz)
ma[(num << 1)].sum1 =
(ma[(num << 1)].sum1 + tag[num] * sum[ma[(num << 1)].siz - 1] % mod) %
mod,
ma[(num << 1)].sum2 =
(ma[(num << 1)].sum2 +
tag[num] * (sum[ma[(num << 1)].siz] - sum[0]) % mod) %
mod;
if (ma[(num << 1 | 1)].siz)
ma[(num << 1 | 1)].sum1 =
(ma[(num << 1 | 1)].sum1 +
tag[num] * sum[ma[(num << 1 | 1)].siz - 1] % mod) %
mod,
ma[(num << 1 | 1)].sum2 =
(ma[(num << 1 | 1)].sum2 +
tag[num] * (sum[ma[(num << 1 | 1)].siz] - sum[0]) %
mod) %
mod;
tag[num] = 0;
}
node operator+(node st, node ch) {
node tr;
tr.sum1 = (st.sum1 + f[st.siz - 1] * ch.sum2 % mod +
(st.siz >= 2) * f[st.siz - 2] * ch.sum1 % mod) %
mod;
tr.sum2 =
(st.sum2 + f[st.siz] * ch.sum2 % mod + f[st.siz - 1] * ch.sum1 % mod) %
mod;
tr.siz = st.siz + ch.siz;
return tr;
}
void build(long long num, long long le, long long rig) {
if (le == rig) {
ma[num].sum1 = a[le] * f[0] % mod, ma[num].sum2 = a[le] * f[1] % mod,
ma[num].siz = 1;
return;
}
build((num << 1), le, ((le + rig) >> 1)),
build((num << 1 | 1), ((le + rig) >> 1) + 1, rig),
ma[num] = ma[(num << 1)] + ma[(num << 1 | 1)];
return;
}
void cov(long long num, long long le, long long rig, long long p, long long x) {
if (le > p || rig < p) return;
if (le == p && rig == p) {
ma[num].sum1 = x * f[0] % mod, ma[num].sum2 = x * f[1] % mod,
ma[num].siz = 1;
return;
}
pushdown(num, le, rig), cov((num << 1), le, ((le + rig) >> 1), p, x),
cov((num << 1 | 1), ((le + rig) >> 1) + 1, rig, p, x),
ma[num] = ma[(num << 1)] + ma[(num << 1 | 1)];
}
void upd(long long num, long long le, long long rig, long long l, long long r,
long long x) {
if (le > r || rig < l) return;
if (le >= l && rig <= r)
ma[num].sum1 = (ma[num].sum1 + x * sum[ma[num].siz - 1] % mod) % mod,
ma[num].sum2 = (ma[num].sum2 + x * (sum[ma[num].siz] - sum[0]) % mod) % mod,
tag[num] += x % mod, tag[num] %= mod;
else
pushdown(num, le, rig), upd((num << 1), le, ((le + rig) >> 1), l, r, x),
upd((num << 1 | 1), ((le + rig) >> 1) + 1, rig, l, r, x),
ma[num] = ma[(num << 1)] + ma[(num << 1 | 1)];
}
node qry(long long num, long long le, long long rig, long long l, long long r) {
if (le >= l && rig <= r)
return ma[num];
else {
pushdown(num, le, rig);
node ty;
if (((le + rig) >> 1) >= l && r >= ((le + rig) >> 1) + 1)
ty = qry((num << 1), le, ((le + rig) >> 1), l, r) +
qry((num << 1 | 1), ((le + rig) >> 1) + 1, rig, l, r);
else if (((le + rig) >> 1) >= l)
ty = qry((num << 1), le, ((le + rig) >> 1), l, r);
else if (r >= ((le + rig) >> 1) + 1)
ty = qry((num << 1 | 1), ((le + rig) >> 1) + 1, rig, l, r);
ma[num] = ma[(num << 1)] + ma[(num << 1 | 1)];
return ty;
}
}
int main() {
n = read(), m = read();
f[0] = 1, sum[0] = 1;
f[1] = 1, sum[1] = 2;
for (long long i = (2); i <= (n * 2); ++i)
f[i] = (f[i - 1] + f[i - 2]) % mod, sum[i] = (sum[i - 1] + f[i]) % mod;
for (long long i = (1); i <= (n); ++i) a[i] = read() % mod;
build(1, 1, n);
for (long long i = (1); i <= (m); ++i) {
long long op = read(), x = read(), y = read();
if (op == 1) cov(1, 1, n, x, y);
if (op == 2) printf("%lld\n", qry(1, 1, n, x, y).sum1 % mod);
if (op == 3) {
long long d = read();
upd(1, 1, n, x, y, d % mod);
}
}
}
``` |
### Prompt
Please formulate a cpp solution 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;
typedef struct Querytype {
int a, b, c;
bool operator==(const Querytype &other) const {
return a == other.a && b == other.b && c == other.c;
}
} Query;
namespace std {
template <>
struct hash<Query> {
std::size_t operator()(const Query &k) const {
return (k.a * 1001 + k.b) * 1001 + k.c;
}
};
} // namespace std
int n, nn;
vector<int> edges[2 * 1001];
unordered_map<Query, char> q;
inline bool lsize(int x) { return x <= n; }
inline bool lnode(int x) { return x > n; }
struct CENT {
typedef bool (*SZ_COUNTER)(int);
typedef bool (*ND_COUNTER)(int);
int *cmax, *csize, n;
vector<int> nodes;
bool *rem;
SZ_COUNTER cntr;
ND_COUNTER nntr;
vector<pair<int, vector<int>>> cents;
vector<map<int, int>> cents_orig;
CENT(int n, SZ_COUNTER cntr, ND_COUNTER nntr) : n(n), cntr(cntr), nntr(nntr) {
cmax = (int *)malloc((this->n + 1) * sizeof(int));
csize = (int *)malloc((this->n + 1) * sizeof(int));
rem = (bool *)malloc((this->n + 1) * sizeof(bool));
memset(rem, false, (this->n + 1) * sizeof(bool));
}
~CENT() {
free(cmax);
free(csize);
free(rem);
}
void dfs(int x, int p) {
nodes.push_back(x);
csize[x] = cntr(x) ? 1 : 0;
cmax[x] = 0;
for (auto i : edges[x])
if (i != -1 && i != p && !rem[i]) {
dfs(i, x);
csize[x] += csize[i];
if (csize[i] > cmax[x]) cmax[x] = csize[i];
}
}
void decompose() {
cents.clear();
vector<int> ztl;
map<int, int> zml;
cents.push_back(make_pair(0, ztl));
cents_orig.push_back(zml);
queue<pair<int, int>> q;
q.push(make_pair(1, 0));
while (!q.empty()) {
auto t = q.front();
q.pop();
nodes.clear();
dfs(t.first, -1);
int ct = -1;
for (auto i : nodes)
if (csize[i] * 2 >= csize[t.first] && cmax[i] * 2 <= csize[t.first] &&
nntr(i)) {
ct = i;
break;
}
if (ct == -1) ct = t.first;
vector<int> ctl;
cents.push_back(make_pair(ct, ctl));
cents_orig.push_back(zml);
int cti = cents.size() - 1, ki = 0;
cents[t.second].second.push_back(cti);
for (auto i : edges[ct])
if (i != -1 && !rem[i]) {
q.push(make_pair(i, cti));
cents_orig[cti][i] = ki++;
}
rem[ct] = true;
}
}
};
int get_leaf(int x) {
if (edges[x].size() <= 1)
return x;
else
return get_leaf(edges[x][1]);
}
char query(int a, int b, int c) {
bool bab = false;
if (a > b) {
swap(b, a);
bab = true;
}
Query qq = {.a = a, .b = b, .c = c};
if (q.find(qq) == q.end()) {
cout << a << " " << b << " " << c << endl;
cin >> q[qq];
}
return !bab || q[qq] == 'X' ? q[qq] : (q[qq] == 'Y' ? 'Z' : 'Y');
}
inline int vfind(const vector<int> &x, int v) {
return find(x.begin(), x.end(), v) - x.begin();
}
void run(int x) {
CENT cent(2 * n - 1, &lsize, &lnode);
cent.decompose();
int i = 1;
while (true) {
auto ct = cent.cents[i].first;
auto cm = cent.cents_orig[i];
const auto &cp = cent.cents[i].second;
char q = query(get_leaf(edges[ct][1]), get_leaf(edges[ct][2]), x);
if (q == 'X') {
if (cm.find(edges[ct][0]) == cm.end()) {
if (edges[ct][0] != -1) {
int idx = vfind(edges[edges[ct][0]], ct);
edges[edges[ct][0]][idx] = nn;
edges[nn].push_back(edges[ct][0]);
} else
edges[nn].push_back(-1);
edges[ct][0] = nn;
edges[x].push_back(nn);
edges[nn].push_back(ct);
edges[nn].push_back(x);
nn++;
break;
} else
i = cp[cm[edges[ct][0]]];
} else {
int k = q == 'Y' ? 2 : 1;
if (cm.find(edges[ct][k]) == cm.end() || !lnode(edges[ct][k])) {
int ke = edges[ct][k];
edges[ke][0] = nn;
edges[ct][k] = nn;
edges[x].push_back(nn);
edges[nn].push_back(ct);
edges[nn].push_back(ke);
edges[nn].push_back(x);
nn++;
break;
} else
i = cp[cm[edges[ct][k]]];
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
edges[1].push_back(n + 1);
edges[2].push_back(n + 1);
edges[n + 1].push_back(-1);
edges[n + 1].push_back(1);
edges[n + 1].push_back(2);
nn = n + 2;
for (int i = 3; i <= n; i++) run(i);
cout << -1 << endl;
for (int i = 1; i < 2 * n - 1; i++) cout << edges[i][0] << " ";
cout << edges[2 * n - 1][0] << endl;
return 0;
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
Mister B has a house in the middle of a giant plain field, which attracted aliens life. For convenience, aliens specified the Cartesian coordinate system on the field in such a way that Mister B's house has coordinates (0, 0). After that they sent three beacons to the field, but something went wrong. One beacon was completely destroyed, while the other two landed in positions with coordinates (m, 0) and (0, n), respectively, but shut down.
Mister B was interested in this devices, so he decided to take them home. He came to the first beacon, placed at (m, 0), lifted it up and carried the beacon home choosing the shortest path. After that he came to the other beacon, placed at (0, n), and also carried it home choosing the shortest path. When first beacon was lifted up, the navigation system of the beacons was activated.
Partially destroyed navigation system started to work in following way.
At time moments when both survived beacons are at points with integer coordinates the system tries to find a location for the third beacon. It succeeds if and only if there is a point with integer coordinates such that the area of the triangle formed by the two survived beacons and this point is equal to s. In this case the system sends a packet of information with beacon positions to aliens, otherwise it doesn't.
Compute how many packets of information system sent while Mister B was moving the beacons.
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases. The next 3·t lines describe t test cases.
Every test case is described in three lines as follows. Note that each parameter is given as a product of three factors.
The first line of a test case contains three space-separated integers: n1, n2, n3 (1 ≤ ni ≤ 106) such that n = n1·n2·n3.
The second line contains three space-separated integers: m1, m2, m3 (1 ≤ mi ≤ 106) such that m = m1·m2·m3.
The third line contains three space-separated integers: s1, s2, s3 (1 ≤ si ≤ 106) such that s = s1·s2·s3.
Note that for hacks only tests with t = 1 allowed.
Output
Print t integers one per line — the answers for each test.
Example
Input
3
2 1 1
2 1 1
1 1 3
1 5 1
2 2 1
1 1 2
10 6 18
2 103 2
13 1 13
Output
4
7
171
Note
First test case contains the following beacon positions: (2, 0) and (0, 2), s = 3. The following packets could be sent: ((2, 0), (0, 2), ( - 1, 0)), ((1, 0), (0, 2), (4, 0)), ((0, 0), (0, 2), (3, 1)), ((0, 0), (0, 1), ( - 6, 0)), where (b1, b2, p) has next description: b1 — first beacon position, b2 — second beacon position, p — some generated point.
Second test case contains the following beacon initial positions: (4, 0) and (0, 5), s = 2. The following packets could be sent: ((4, 0), (0, 5), (0, 4)), ((3, 0), (0, 5), (2, 3)), ((2, 0), (0, 5), (2, 2)), ((1, 0), (0, 5), (1, 4)), ((0, 0), (0, 4), (0, - 1)), ((0, 0), (0, 2), (2, 0)), ((0, 0), (0, 1), (4, 0)).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <class T>
using vv = vector<vector<T>>;
template <class T>
ostream &operator<<(ostream &os, const vector<T> &t) {
os << "{";
for (int(i) = 0; (i) < (t.size()); ++(i)) {
os << t[i] << ",";
}
os << "}" << endl;
return os;
}
template <class S, class T>
ostream &operator<<(ostream &os, const pair<S, T> &t) {
return os << "(" << t.first << "," << t.second << ")";
}
template <class T>
inline bool MX(T &l, const T &r) {
return l < r ? l = r, 1 : 0;
}
template <class T>
inline bool MN(T &l, const T &r) {
return l > r ? l = r, 1 : 0;
}
vector<string> s_p_l_i_t(const string &s, char c) {
vector<string> v;
int d = 0, f = 0;
string t;
for (char c : s) {
if (!d && c == ',')
v.push_back(t), t = "";
else
t += c;
if (c == '\"' || c == '\'') f ^= 1;
if (!f && c == '(') ++d;
if (!f && c == ')') --d;
}
v.push_back(t);
return move(v);
}
void e_r_r(vector<string>::iterator it) {}
template <typename T, typename... Args>
void e_r_r(vector<string>::iterator it, T a, Args... args) {
if (*it == " 1" || *it == "1")
cerr << endl;
else
cerr << it->substr((*it)[0] == ' ', it->length()) << " = " << a << ", ";
e_r_r(++it, args...);
}
const long long MOD = 1e9 + 7;
const int MAX_P = 1123456;
int prime[MAX_P];
void Fact(int n, map<long long, long long> &re) {
while (prime[n]) {
++re[prime[n]];
n /= prime[n];
}
if (n > 1) ++re[n];
}
void pre() {
int i, j, k;
for (i = 2; i < MAX_P; i++) {
if (prime[i] == 0)
for (long long j = 1ll * i * i; j < MAX_P; j += i) prime[j] = i;
}
}
map<pair<pair<long long, long long>, long long>, long long> memo;
long long dfs(vector<pair<long long, long long>> &ps, int i, long long x) {
if (ps.size() == i) return x >= 0;
long long re = dfs(ps, i + 1, x);
for (int(_) = 0; (_) < (ps[i].second); ++(_)) {
x /= ps[i].first;
if (!x) break;
re += dfs(ps, i + 1, x);
}
return re;
}
long long dfs2(vector<pair<long long, long long>> &ps, int i, long long x) {
if (ps.size() == i) {
if (!x) return 0;
long long re = 0;
int n = ps.size();
for (int(i) = 0; (i) < (1 << n); ++(i)) {
long long t = x;
for (int(j) = 0; (j) < (n); ++(j))
if (i >> j & 1) t /= ps[j].first;
re += (__builtin_popcount(i) % 2 ? -t : t);
}
return re;
}
long long re = dfs2(ps, i + 1, x);
for (int(_) = 0; (_) < (ps[i].second); ++(_)) {
x /= ps[i].first;
if (!x) break;
re += dfs2(ps, i + 1, x);
}
return re;
}
int main() {
pre();
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(0);
int T;
cin >> T;
while (T--) {
map<long long, long long> xs, ys, ss;
long long first = 1, second = 1, S = 1;
for (int(i) = 0; (i) < (3); ++(i)) {
long long t;
cin >> t;
first *= t;
Fact(t, xs);
}
for (int(i) = 0; (i) < (3); ++(i)) {
long long t;
cin >> t;
second *= t;
Fact(t, ys);
}
for (int(i) = 0; (i) < (3); ++(i)) {
long long t;
cin >> t;
S *= t;
Fact(t, ss);
}
S *= 2;
++ss[2];
if (memo.count(make_pair(pair<long long, long long>(first, second), S))) {
cout << memo[make_pair(pair<long long, long long>(first, second), S)]
<< endl;
}
long long &re =
memo[make_pair(pair<long long, long long>(first, second), S)];
vector<pair<long long, long long>> ps((ss).begin(), (ss).end());
reverse((ps).begin(), (ps).end());
re += dfs(ps, 0, first);
map<long long, long long> ts;
for (pair<long long, long long> p : xs) {
if (ss[p.first] < p.second) ts[p.first] = ss[p.first];
}
vector<pair<long long, long long>> tv((ts).begin(), (ts).end());
re += dfs2(tv, 0, second);
cout << re << endl;
}
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
I’m planning to have a party on my birthday. Many of my friends will come to the party. Some of them will come with one or more pieces of cakes, but it is not certain if the number of the cakes is a multiple of the number of people coming.
I wish to enjoy the cakes equally among the partiers. So, I decided to apply the following rules. First, all the party attendants are given the same number of cakes. If some remainder occurs, a piece goes on a priority basis to the party host (that’s me!). How many pieces of cake can I enjoy?
Given the number of my friends and cake information, make a program to calculate how many pieces of cake I can enjoy. Note that I am not counted in the number of my friends.
Input
The input is given in the following format.
$N$ $C$
$p_1$ $p_2$ ... $p_C$
The first line provides the number of my friends $N$ ($1 \leq N \leq 100$) and the number of those among them who brought one or more pieces of cake with them $C$ ($1 \leq C \leq N$). The second line provides an array of integers $p_i$ ($1 \leq p_i \leq100$), each of which shows the number of cakes of the $i$-th friend of mine who was willing to come up with one or more pieces of cake.
Output
Output the number of cakes I can enjoy.
Examples
Input
5 4
5 5 6 5
Output
4
Input
7 5
8 8 8 8 8
Output
5
Input
100 3
3 3 3
Output
1
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,c,x,sum=0,m;
cin>>n>>c;
for(int i=1;i<=c;++i){
cin>>x;
sum+=x;
}
m=sum/(n+1);
if(sum%(n+1))++m;
cout<<m<<endl;
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
This is the easy version of the problem. The difference between the versions is the constraint on n and the required number of operations. You can make hacks only if all versions of the problem are solved.
There are two binary strings a and b of length n (a binary string is a string consisting of symbols 0 and 1). In an operation, you select a prefix of a, and simultaneously invert the bits in the prefix (0 changes to 1 and 1 changes to 0) and reverse the order of the bits in the prefix.
For example, if a=001011 and you select the prefix of length 3, it becomes 011011. Then if you select the entire string, it becomes 001001.
Your task is to transform the string a into b in at most 3n operations. It can be proved that it is always possible.
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 3t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 1000) — the length of the binary strings.
The next two lines contain two binary strings a and b of length n.
It is guaranteed that the sum of n across all test cases does not exceed 1000.
Output
For each test case, output an integer k (0≤ k≤ 3n), followed by k integers p_1,…,p_k (1≤ p_i≤ n). Here k is the number of operations you use and p_i is the length of the prefix you flip in the i-th operation.
Example
Input
5
2
01
10
5
01011
11100
2
01
01
10
0110011011
1000110100
1
0
1
Output
3 1 2 1
6 5 2 5 3 1 2
0
9 4 1 2 10 4 1 2 1 5
1 1
Note
In the first test case, we have 01→ 11→ 00→ 10.
In the second test case, we have 01011→ 00101→ 11101→ 01000→ 10100→ 00100→ 11100.
In the third test case, the strings are already the same. Another solution is to flip the prefix of length 2, which will leave a unchanged.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
inline int add(int a, int b) {
a += b;
if (a >= 1000000007) a -= 1000000007;
return a;
}
inline int mul(int a, int b) { return (a * 1ll * b) % 1000000007; }
inline int power(int a, int b) {
int rt = 1;
while (b > 0) {
if (b & 1) rt = mul(rt, a);
a = mul(a, a);
b >>= 1;
}
return rt;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
string a, b;
cin >> a >> b;
vector<int> ans;
for (int i = 0; i < n; i++) {
if (a[i] != b[i]) {
if (i > 0) ans.push_back(i + 1);
ans.push_back(1);
if (i > 0) ans.push_back(i + 1);
}
}
cout << ans.size() << " ";
for (auto x : ans) cout << x << " ";
cout << "\n";
}
return 0;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
In an English class Nick had nothing to do at all, and remembered about wonderful strings called palindromes. We should remind you that a string is called a palindrome if it can be read the same way both from left to right and from right to left. Here are examples of such strings: «eye», «pop», «level», «aba», «deed», «racecar», «rotor», «madam».
Nick started to look carefully for all palindromes in the text that they were reading in the class. For each occurrence of each palindrome in the text he wrote a pair — the position of the beginning and the position of the ending of this occurrence in the text. Nick called each occurrence of each palindrome he found in the text subpalindrome. When he found all the subpalindromes, he decided to find out how many different pairs among these subpalindromes cross. Two subpalindromes cross if they cover common positions in the text. No palindrome can cross itself.
Let's look at the actions, performed by Nick, by the example of text «babb». At first he wrote out all subpalindromes:
• «b» — 1..1 • «bab» — 1..3 • «a» — 2..2 • «b» — 3..3 • «bb» — 3..4 • «b» — 4..4
Then Nick counted the amount of different pairs among these subpalindromes that cross. These pairs were six:
1. 1..1 cross with 1..3 2. 1..3 cross with 2..2 3. 1..3 cross with 3..3 4. 1..3 cross with 3..4 5. 3..3 cross with 3..4 6. 3..4 cross with 4..4
Since it's very exhausting to perform all the described actions manually, Nick asked you to help him and write a program that can find out the amount of different subpalindrome pairs that cross. Two subpalindrome pairs are regarded as different if one of the pairs contains a subpalindrome that the other does not.
Input
The first input line contains integer n (1 ≤ n ≤ 2·106) — length of the text. The following line contains n lower-case Latin letters (from a to z).
Output
In the only line output the amount of different pairs of two subpalindromes that cross each other. Output the answer modulo 51123987.
Examples
Input
4
babb
Output
6
Input
2
aa
Output
2
### Response
```cpp
#include <bits/stdc++.h>
#pragma GCC target("sse4,avx")
const int p = 51123987;
struct string_view {
const std::string& str;
size_t left;
size_t right;
string_view(const std::string& str, size_t left, size_t right)
: str(str), left(left), right(right) {}
string_view(const string_view& view, size_t left, size_t right)
: str(view.str), left(view.left + left), right(view.left + right) {}
size_t size() const { return right - left; }
char operator[](size_t idx) const { return str[left + idx]; }
};
struct Solution {
std::vector<size_t> selfZ;
std::vector<size_t> commonZ;
void getSelfZ(const string_view& view) {
size_t n = view.size();
selfZ[0] = n;
size_t right_bound = 1;
size_t offset = 0;
for (size_t i = 1; i < n; i++) {
if (i >= right_bound || selfZ[i - offset] + i >= right_bound) {
size_t start = std::max(i, right_bound);
for (; start < n && view[start] == view[start - i]; start++) {
}
selfZ[i] = start - i;
right_bound = start;
offset = i;
} else {
selfZ[i] = selfZ[i - offset];
}
}
}
void getZ(const string_view& view, size_t maxn, const string_view& pattern) {
size_t n = view.size();
size_t m = pattern.size();
size_t right_bound = 0;
size_t offset = 0;
for (size_t i = 0; i < maxn; i++) {
if (i >= right_bound || selfZ[i - offset] + i >= right_bound) {
size_t start = std::max(i, right_bound);
for (; start < std::min(n, m + i) && view[start] == pattern[start - i];
start++) {
}
commonZ[i] = start - i;
right_bound = start;
offset = i;
} else {
commonZ[i] = selfZ[i - offset];
}
}
}
void getPalindromes(const string_view& view, const string_view& rview,
std::vector<size_t>& maxLen) {
if (view.size() <= 3) {
for (size_t i = 0; i < view.size(); i++) {
for (size_t j = i; j < view.size(); j++) {
bool good = true;
for (size_t k = i, l = j; k < l; k++, l--) {
if (view[k] != view[l]) {
good = false;
break;
}
}
if (good) {
maxLen[i + j + view.left * 2] =
std::max(maxLen[i + j + view.left * 2], j - i + 1);
}
}
}
return;
}
size_t middle = view.size() / 2;
size_t revMiddle = view.size() - middle;
string_view viewHalf(view, middle, view.size());
getSelfZ(viewHalf);
getZ(rview, revMiddle, viewHalf);
for (size_t i = 0; i < revMiddle; i++) {
size_t rightPos = i + commonZ[i];
if (rightPos > revMiddle) {
size_t left = view.right - rightPos;
size_t right = view.left + middle + commonZ[i] - 1;
maxLen[left + right] = std::max(maxLen[left + right], right - left + 1);
}
}
string_view viewHalf2(rview, revMiddle, rview.size());
getSelfZ(viewHalf2);
getZ(view, middle + 1, viewHalf2);
for (size_t i = 0; i <= middle; i++) {
size_t rightPos = i + commonZ[i];
if (rightPos > middle) {
size_t left = view.left + middle - commonZ[i];
size_t right = view.left + rightPos - 1;
maxLen[left + right] = std::max(maxLen[left + right], right - left + 1);
}
}
getPalindromes(string_view(view, 0, middle),
string_view(rview, revMiddle, rview.size()), maxLen);
getPalindromes(string_view(view, middle, view.size()),
string_view(rview, 0, revMiddle), maxLen);
}
static int mul32(int x, int y, int p) { return int(int64_t(x) * y % p); }
void run(std::istream& in, std::ostream& out) {
size_t n;
in >> n;
std::string s;
in >> s;
std::string r = s;
std::reverse(r.begin(), r.end());
std::vector<size_t> maxLen(2 * n - 1);
selfZ.resize(n);
commonZ.resize(n);
getPalindromes(string_view(s, 0, n), string_view(r, 0, n), maxLen);
std::vector<int> leftBounds(n);
std::vector<int> allPalindromes(n);
for (size_t i = 0; i < maxLen.size(); i++) {
if (maxLen[i] == 0) continue;
size_t left = (i + 1 - maxLen[i]) / 2;
size_t middle = left + (maxLen[i] + 1) / 2;
leftBounds[left]++;
if (middle < n) leftBounds[middle]--;
}
for (size_t i = 1; i < leftBounds.size(); i++) {
leftBounds[i] += leftBounds[i - 1];
}
for (size_t i = 0; i < maxLen.size(); i++) {
if (maxLen[i] == 0) continue;
size_t left = (i + 1 - maxLen[i]) / 2;
size_t middle1 = left + (maxLen[i] + 1) / 2;
size_t middle2 = left + (maxLen[i] + 2) / 2;
size_t right = left + maxLen[i] + 1;
allPalindromes[left]++;
if (middle1 < n) allPalindromes[middle1]--;
if (middle2 < n) allPalindromes[middle2]--;
if (right < n) allPalindromes[right]++;
}
for (size_t i = 1; i < allPalindromes.size(); i++) {
allPalindromes[i] = (allPalindromes[i] + allPalindromes[i - 1]) % p;
}
for (size_t i = 1; i < allPalindromes.size(); i++) {
allPalindromes[i] = (allPalindromes[i] + allPalindromes[i - 1]) % p;
}
int res = 0;
for (size_t i = 0; i < allPalindromes.size(); i++) {
res += mul32(allPalindromes[i] - leftBounds[i], leftBounds[i], p);
if (leftBounds[i] & 1) {
res += mul32((leftBounds[i] - 1) / 2, leftBounds[i], p);
} else {
res += mul32(leftBounds[i] - 1, leftBounds[i] / 2, p);
}
res = res % p;
}
if (res < 0) res += p;
out << res << std::endl;
}
};
int main() {
std::cin.sync_with_stdio(false);
std::cin.tie(nullptr);
Solution().run(std::cin, std::cout);
return 0;
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
Capitalization is writing a word with its first letter as a capital letter. Your task is to capitalize the given word.
Note, that during capitalization all the letters except the first one remains unchanged.
Input
A single line contains a non-empty word. This word consists of lowercase and uppercase English letters. The length of the word will not exceed 103.
Output
Output the given word after capitalization.
Examples
Input
ApPLe
Output
ApPLe
Input
konjac
Output
Konjac
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string word;
cin >> word;
if (word[0] >= 97 && word[0] <= 122) word[0] = word[0] - 32;
cout << word << endl;
return 0;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
The city Valera lives in is going to hold elections to the city Parliament.
The city has n districts and n - 1 bidirectional roads. We know that from any district there is a path along the roads to any other district. Let's enumerate all districts in some way by integers from 1 to n, inclusive. Furthermore, for each road the residents decided if it is the problem road or not. A problem road is a road that needs to be repaired.
There are n candidates running the elections. Let's enumerate all candidates in some way by integers from 1 to n, inclusive. If the candidate number i will be elected in the city Parliament, he will perform exactly one promise — to repair all problem roads on the way from the i-th district to the district 1, where the city Parliament is located.
Help Valera and determine the subset of candidates such that if all candidates from the subset will be elected to the city Parliament, all problem roads in the city will be repaired. If there are several such subsets, you should choose the subset consisting of the minimum number of candidates.
Input
The first line contains a single integer n (2 ≤ n ≤ 105) — the number of districts in the city.
Then n - 1 lines follow. Each line contains the description of a city road as three positive integers xi, yi, ti (1 ≤ xi, yi ≤ n, 1 ≤ ti ≤ 2) — the districts connected by the i-th bidirectional road and the road type. If ti equals to one, then the i-th road isn't the problem road; if ti equals to two, then the i-th road is the problem road.
It's guaranteed that the graph structure of the city is a tree.
Output
In the first line print a single non-negative number k — the minimum size of the required subset of candidates. Then on the second line print k space-separated integers a1, a2, ... ak — the numbers of the candidates that form the required subset. If there are multiple solutions, you are allowed to print any of them.
Examples
Input
5
1 2 2
2 3 2
3 4 2
4 5 2
Output
1
5
Input
5
1 2 1
2 3 2
2 4 1
4 5 1
Output
1
3
Input
5
1 2 2
1 3 2
1 4 2
1 5 2
Output
4
5 4 3 2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 2;
const long long MOD = 1e9 + 7;
const long long Inf = MOD * MOD;
const long double eps = 1e-7;
const long long dx[] = {1, 0, 0, 0};
const long long dy[] = {0, 1, 1, -1};
long long n, u, v, w, timer = 0, t = 1;
vector<int> adj[N];
vector<int> Ans;
map<pair<int, int>, bool> M;
bool vis[N];
bool dfs(int u, int par) {
int Res = false;
for (auto x : adj[u]) {
if (x != par) {
Res |= dfs(x, u);
}
}
if (M[{u, par}] && !Res) {
Ans.push_back(u);
Res = true;
}
return Res;
}
void Solve() {
scanf("%lld", &n);
for (int i = 1; i < n; ++i) {
scanf("%lld%lld%lld", &u, &v, &w);
M[{u, v}] = w - 1;
M[{v, u}] = w - 1;
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs(1, 0);
printf("%d\n", (int)Ans.size());
for (auto x : Ans) {
cout << x << " ";
}
}
int main() {
while (t--) {
++timer;
Solve();
puts("");
}
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
A big company decided to launch a new series of rectangular displays, and decided that the display must have exactly n pixels.
Your task is to determine the size of the rectangular display — the number of lines (rows) of pixels a and the number of columns of pixels b, so that:
* there are exactly n pixels on the display;
* the number of rows does not exceed the number of columns, it means a ≤ b;
* the difference b - a is as small as possible.
Input
The first line contains the positive integer n (1 ≤ n ≤ 106) — the number of pixels display should have.
Output
Print two integers — the number of rows and columns on the display.
Examples
Input
8
Output
2 4
Input
64
Output
8 8
Input
5
Output
1 5
Input
999999
Output
999 1001
Note
In the first example the minimum possible difference equals 2, so on the display should be 2 rows of 4 pixels.
In the second example the minimum possible difference equals 0, so on the display should be 8 rows of 8 pixels.
In the third example the minimum possible difference equals 4, so on the display should be 1 row of 5 pixels.
### Response
```cpp
#include <bits/stdc++.h>
int n, k;
int main() {
scanf("%d", &n);
for (int i = 1; i * i <= n; i++) {
if (n % i == 0) k = i;
}
printf("%d %d", k, n / k);
return 0;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
Consider a conveyor belt represented using a grid consisting of n rows and m columns. The cell in the i-th row from the top and the j-th column from the left is labelled (i,j).
Every cell, except (n,m), has a direction R (Right) or D (Down) assigned to it. If the cell (i,j) is assigned direction R, any luggage kept on that will move to the cell (i,j+1). Similarly, if the cell (i,j) is assigned direction D, any luggage kept on that will move to the cell (i+1,j). If at any moment, the luggage moves out of the grid, it is considered to be lost.
There is a counter at the cell (n,m) from where all luggage is picked. A conveyor belt is called functional if and only if any luggage reaches the counter regardless of which cell it is placed in initially. More formally, for every cell (i,j), any luggage placed in this cell should eventually end up in the cell (n,m).
This may not hold initially; you are, however, allowed to change the directions of some cells to make the conveyor belt functional. Please determine the minimum amount of cells you have to change.
Please note that it is always possible to make any conveyor belt functional by changing the directions of some set of cells.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10). Description of the test cases follows.
The first line of each test case contains two integers n, m (1 ≤ n ≤ 100, 1 ≤ m ≤ 100) — the number of rows and columns, respectively.
The following n lines each contain m characters. The j-th character in the i-th line, a_{i,j} is the initial direction of the cell (i, j). Please note that a_{n,m}= C.
Output
For each case, output in a new line the minimum number of cells that you have to change to make the conveyor belt functional.
Example
Input
4
3 3
RRD
DDR
RRC
1 4
DDDC
6 9
RDDDDDRRR
RRDDRRDDD
RRDRDRRDR
DDDDRDDRR
DRRDRDDDR
DDRDRRDDC
1 1
C
Output
1
3
9
0
Note
In the first case, just changing the direction of (2,3) to D is enough.
You can verify that the resulting belt is functional. For example, if we place any luggage at (2,2), it first moves to (3,2) and then to (3,3).
In the second case, we have no option but to change the first 3 cells from D to R making the grid equal to RRRC.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, m, ans = 0;
cin >> n >> m;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
if (i == n - 1) {
for (int j = 0; j < s.size() - 1; j++) {
if (s[j] == 'D') ans++;
}
} else {
if (s[s.size() - 1] == 'R') ans++;
}
}
cout << ans << endl;
}
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
It turns out that you are a great fan of rock band AC/PE. Peter learned that and started the following game: he plays the first song of the list of n songs of the group, and you have to find out the name of the song. After you tell the song name, Peter immediately plays the following song in order, and so on.
The i-th song of AC/PE has its recognizability pi. This means that if the song has not yet been recognized by you, you listen to it for exactly one more second and with probability of pi percent you recognize it and tell it's name. Otherwise you continue listening it. Note that you can only try to guess it only when it is integer number of seconds after the moment the song starts playing.
In all AC/PE songs the first words of chorus are the same as the title, so when you've heard the first ti seconds of i-th song and its chorus starts, you immediately guess its name for sure.
For example, in the song Highway To Red the chorus sounds pretty late, but the song has high recognizability. In the song Back In Blue, on the other hand, the words from the title sound close to the beginning of the song, but it's hard to name it before hearing those words. You can name both of these songs during a few more first seconds.
Determine the expected number songs of you will recognize if the game lasts for exactly T seconds (i. e. you can make the last guess on the second T, after that the game stops).
If all songs are recognized faster than in T seconds, the game stops after the last song is recognized.
Input
The first line of the input contains numbers n and T (1 ≤ n ≤ 5000, 1 ≤ T ≤ 5000), separated by a space. Next n lines contain pairs of numbers pi and ti (0 ≤ pi ≤ 100, 1 ≤ ti ≤ T). The songs are given in the same order as in Petya's list.
Output
Output a single number — the expected number of the number of songs you will recognize in T seconds. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Examples
Input
2 2
50 2
10 1
Output
1.500000000
Input
2 2
0 2
100 2
Output
1.000000000
Input
3 3
50 3
50 2
25 2
Output
1.687500000
Input
2 2
0 2
0 2
Output
1.000000000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5e3 + 10;
int p[MAXN], c[MAXN];
double dp[MAXN][MAXN];
inline double qpow(double x, int y) {
double ret = 1;
while (y) {
if (y & 1) ret *= x;
x *= x, y >>= 1;
}
return ret;
}
int main() {
int n, t;
scanf("%d%d", &n, &t);
for (int i = 0; i != n; ++i) {
scanf("%d%d", p + i, c + i);
}
dp[0][0] = 1;
double ans = 0;
for (int i = 0; i != n; ++i) {
double pp = p[i] / 100.0;
double now = 0;
double r = qpow(1 - pp, c[i] - 1) * pp;
double r2 = qpow(1 - pp, c[i] - 1);
for (int j = 0; j != t; ++j) {
now *= 1 - pp;
now += dp[i][j] * pp;
if (j + 1 >= c[i]) {
now -= dp[i][j - c[i] + 1] * r;
dp[i + 1][j + 1] = now + dp[i][j - c[i] + 1] * r2;
} else
dp[i + 1][j + 1] = now;
}
for (int j = 0; j != t + 1; ++j) {
ans += dp[i + 1][j];
}
}
printf("%.8lf", ans);
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
Mancala is a game famous in the Middle East. It is played on a board that consists of 14 holes.
<image>
Initially, each hole has a_i stones. When a player makes a move, he chooses a hole which contains a positive number of stones. He takes all the stones inside it and then redistributes these stones one by one in the next holes in a counter-clockwise direction.
Note that the counter-clockwise order means if the player takes the stones from hole i, he will put one stone in the (i+1)-th hole, then in the (i+2)-th, etc. If he puts a stone in the 14-th hole, the next one will be put in the first hole.
After the move, the player collects all the stones from holes that contain even number of stones. The number of stones collected by player is the score, according to Resli.
Resli is a famous Mancala player. He wants to know the maximum score he can obtain after one move.
Input
The only line contains 14 integers a_1, a_2, …, a_{14} (0 ≤ a_i ≤ 10^9) — the number of stones in each hole.
It is guaranteed that for any i (1≤ i ≤ 14) a_i is either zero or odd, and there is at least one stone in the board.
Output
Output one integer, the maximum possible score after one move.
Examples
Input
0 1 1 0 0 0 0 0 0 7 0 0 0 0
Output
4
Input
5 1 1 1 1 0 0 0 0 0 0 0 0 0
Output
8
Note
In the first test case the board after the move from the hole with 7 stones will look like 1 2 2 0 0 0 0 0 0 0 1 1 1 1. Then the player collects the even numbers and ends up with a score equal to 4.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n = 14;
vector<long long int> holes(n);
for (int i = 0; i < n; i++) cin >> holes[i];
long long int ans = 0;
for (int i = 0; i < n; i++) {
vector<long long int> aux = holes;
long long int cant = holes[i];
if (cant == 0) continue;
long long int cuno = cant / 14ll, sobra = cant % 14ll;
aux[i] = 0;
for (int j = 0; j < n; j++) {
aux[j] += cuno;
}
int idx = i + 1;
while (sobra--) {
if (idx == 14) idx = 0;
aux[idx]++;
idx++;
}
long long int res = 0;
for (int j = 0; j < n; j++) {
if (aux[j] % 2 == 0) res += aux[j];
}
ans = max(res, ans);
}
cout << ans << '\n';
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
The educational program (AHK Education) of the Aiz Broadcasting Association broadcasts a handicraft program for children, "Play with Tsukuro". This time I will make a box with sticks, but I would like to see if I can make a rectangular parallelepiped using the 12 sticks I prepared. However, the stick must not be cut or broken.
Given the lengths of the twelve bars, write a program to determine if you can create a rectangular parallelepiped with all of them as sides.
Input
The input is given in the following format.
e1 e2 ... e12
The input consists of one line and is given the integer ei (1 ≤ ei ≤ 100) representing the length of each bar.
Output
If a rectangular parallelepiped can be created, "yes" is output, and if it cannot be created, "no" is output. However, since a cube is a kind of rectangular parallelepiped, "yes" is output even if it is a cube.
Examples
Input
1 1 3 4 8 9 7 3 4 5 5 5
Output
no
Input
1 1 2 2 3 1 2 3 3 3 1 2
Output
yes
### Response
```cpp
#include <stdio.h>
int size[3],a[12],s[3];
bool dfs(int now){
if(now>=12)return true;
else{
for(int i=0;i<3;i++)if(s[i]==-1){
size[i]=1;
s[i]=a[now];
if(dfs(now+1))return true;
s[i]=-1;
size[i]=0;
}
else if(s[i]==a[now]&&size[i]<5){
size[i]++;
if(dfs(now+1))return true;
size[i]--;
}
return false;
}
}
int main(){
for(int i=0;i<3;i++)s[i]=-1;
for(int i=0;i<12;i++)scanf("%d",&a[i]);
if(dfs(0))printf("yes\n");
else printf("no\n");
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
Little Dima has two sequences of points with integer coordinates: sequence (a1, 1), (a2, 2), ..., (an, n) and sequence (b1, 1), (b2, 2), ..., (bn, n).
Now Dima wants to count the number of distinct sequences of points of length 2·n that can be assembled from these sequences, such that the x-coordinates of points in the assembled sequence will not decrease. Help him with that. Note that each element of the initial sequences should be used exactly once in the assembled sequence.
Dima considers two assembled sequences (p1, q1), (p2, q2), ..., (p2·n, q2·n) and (x1, y1), (x2, y2), ..., (x2·n, y2·n) distinct, if there is such i (1 ≤ i ≤ 2·n), that (pi, qi) ≠ (xi, yi).
As the answer can be rather large, print the remainder from dividing the answer by number m.
Input
The first line contains integer n (1 ≤ n ≤ 105). The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109). The third line contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 109). The numbers in the lines are separated by spaces.
The last line contains integer m (2 ≤ m ≤ 109 + 7).
Output
In the single line print the remainder after dividing the answer to the problem by number m.
Examples
Input
1
1
2
7
Output
1
Input
2
1 2
2 3
11
Output
2
Note
In the first sample you can get only one sequence: (1, 1), (2, 1).
In the second sample you can get such sequences : (1, 1), (2, 2), (2, 1), (3, 2); (1, 1), (2, 1), (2, 2), (3, 2). Thus, the answer is 2.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
map<long long, long long> cnt;
long long a[200001], n, m, res, same;
int main() {
cin >> n;
for (int i = 0; i < n * 2; i++) {
cin >> a[i], cnt[a[i]]++;
if (i >= n)
if (a[i - n] == a[i]) same++;
}
cin >> m;
res = 1;
for (int i = 0; i < 2 * n; i++) {
for (int j = 1; j <= cnt[a[i]]; j++) {
res *= j;
while (res % 2 == 0 && same) res /= 2, same--;
res %= m;
}
cnt[a[i]] = 0;
}
cout << res << endl;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
The best night ever in the world has come! It's 8 p.m. of December 24th, yes, the night of Cristmas Eve. Santa Clause comes to a silent city with ringing bells. Overtaking north wind, from a sleigh a reindeer pulls she shoot presents to soxes hanged near windows for children.
The sleigh she is on departs from a big christmas tree on the fringe of the city. Miracle power that the christmas tree spread over the sky like a web and form a paths that the sleigh can go on. Since the paths with thicker miracle power is easier to go, these paths can be expressed as undirected weighted graph.
Derivering the present is very strict about time. When it begins dawning the miracle power rapidly weakens and Santa Clause can not continue derivering any more. Her pride as a Santa Clause never excuses such a thing, so she have to finish derivering before dawning.
The sleigh a reindeer pulls departs from christmas tree (which corresponds to 0th node), and go across the city to the opposite fringe (n-1 th node) along the shortest path. Santa Clause create presents from the miracle power and shoot them from the sleigh the reindeer pulls at his full power. If there are two or more shortest paths, the reindeer selects one of all shortest paths with equal probability and go along it.
By the way, in this city there are p children that wish to see Santa Clause and are looking up the starlit sky from their home. Above the i-th child's home there is a cross point of the miracle power that corresponds to c[i]-th node of the graph. The child can see Santa Clause if (and only if) Santa Clause go through the node.
Please find the probability that each child can see Santa Clause.
Constraints
* 3 ≤ n ≤ 100
* There are no parallel edges and a edge whose end points are identical.
* 0 < weight of the edge < 10000
Input
Input consists of several datasets.
The first line of each dataset contains three integers n, m, p, which means the number of nodes and edges of the graph, and the number of the children. Each node are numbered 0 to n-1.
Following m lines contains information about edges. Each line has three integers. The first two integers means nodes on two endpoints of the edge. The third one is weight of the edge.
Next p lines represent c[i] respectively.
Input terminates when n = m = p = 0.
Output
For each dataset, output p decimal values in same order as input. Write a blank line after that.
You may output any number of digit and may contain an error less than 1.0e-6.
Example
Input
3 2 1
0 1 2
1 2 3
1
4 5 2
0 1 1
0 2 1
1 2 1
1 3 1
2 3 1
1
2
0 0 0
Output
1.00000000
0.50000000
0.50000000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
#define dump(...) cout<<"# "<<#__VA_ARGS__<<'='<<(__VA_ARGS__)<<endl
#define repi(i,a,b) for(int i=int(a);i<int(b);i++)
#define peri(i,a,b) for(int i=int(b);i-->int(a);)
#define rep(i,n) repi(i,0,n)
#define per(i,n) peri(i,0,n)
#define all(c) begin(c),end(c)
#define mp make_pair
#define mt make_tuple
typedef unsigned int uint;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef vector<string> vs;
template<typename T1,typename T2>
ostream& operator<<(ostream& os,const pair<T1,T2>& p){
return os<<'('<<p.first<<','<<p.second<<')';
}
template<typename Tuple>
void print_tuple(ostream&,const Tuple&){}
template<typename Car,typename... Cdr,typename Tuple>
void print_tuple(ostream& os,const Tuple& t){
print_tuple<Cdr...>(os,t);
os<<(sizeof...(Cdr)?",":"")<<get<sizeof...(Cdr)>(t);
}
template<typename... Args>
ostream& operator<<(ostream& os,const tuple<Args...>& t){
print_tuple<Args...>(os<<'(',t);
return os<<')';
}
template<typename Ch,typename Tr,typename C,typename=decltype(begin(C()))>
basic_ostream<Ch,Tr>& operator<<(basic_ostream<Ch,Tr>& os,const C& c){
os<<'[';
for(auto i=begin(c);i!=end(c);++i)
os<<(i==begin(c)?"":" ")<<*i;
return os<<']';
}
constexpr int INF=1e9;
constexpr int MOD=1e9+7;
constexpr double EPS=1e-9;
struct Edge{
int src,dst,weight;
Edge(){}
Edge(int s,int d,int w):src(s),dst(d),weight(w){}
};
typedef vector<vector<Edge>> Graph;
void chmin(int& a,int b)
{
a=min(a,b);
}
int main()
{
for(int n,m,s;cin>>n>>m>>s && n|m|s;){
Graph g(n);
rep(i,m){
int u,v,w; cin>>u>>v>>w;
g[u].emplace_back(u,v,w);
g[v].emplace_back(v,u,w);
}
vi cs(s);
rep(i,s) cin>>cs[i];
vvi dp(n,vi(n,INF));
rep(i,n) dp[i][i]=0;
rep(i,n) for(auto e:g[i]) chmin(dp[e.src][e.dst],e.weight);
rep(k,n) rep(i,n) rep(j,n) chmin(dp[i][j],dp[i][k]+dp[k][j]);
vd cnt1(n,0); cnt1[0]=1;
{
Graph gg(n);
rep(i,n) for(auto e:g[i]) if(dp[0][e.src]+e.weight+dp[e.dst][n-1]==dp[0][n-1])
gg[e.src].push_back(e);
vi is(n); iota(all(is),0);
sort(all(is),[&](int i,int j){return dp[0][i]<dp[0][j];});
for(auto u:is) for(auto e:gg[u]) cnt1[e.dst]+=cnt1[u];
}
vd cnt2(n,0); cnt2[n-1]=1;
{
Graph gg(n);
rep(i,n) for(auto e:g[i]) if(dp[0][e.src]+e.weight+dp[e.dst][n-1]==dp[0][n-1])
gg[e.dst].emplace_back(e.dst,e.src,e.weight);
vi is(n); iota(all(is),0);
sort(all(is),[&](int i,int j){return dp[n-1][i]<dp[n-1][j];});
for(auto u:is) for(auto e:gg[u]) cnt2[e.dst]+=cnt2[u];
}
for(auto i:cs) printf("%.9f\n",cnt1[i]*cnt2[i]/cnt1[n-1]); puts("");
}
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
One day Dima and Alex had an argument about the price and quality of laptops. Dima thinks that the more expensive a laptop is, the better it is. Alex disagrees. Alex thinks that there are two laptops, such that the price of the first laptop is less (strictly smaller) than the price of the second laptop but the quality of the first laptop is higher (strictly greater) than the quality of the second laptop.
Please, check the guess of Alex. You are given descriptions of n laptops. Determine whether two described above laptops exist.
Input
The first line contains an integer n (1 ≤ n ≤ 105) — the number of laptops.
Next n lines contain two integers each, ai and bi (1 ≤ ai, bi ≤ n), where ai is the price of the i-th laptop, and bi is the number that represents the quality of the i-th laptop (the larger the number is, the higher is the quality).
All ai are distinct. All bi are distinct.
Output
If Alex is correct, print "Happy Alex", otherwise print "Poor Alex" (without the quotes).
Examples
Input
2
1 2
2 1
Output
Happy Alex
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long n, a, b;
vector<pair<long, long> > v;
cin >> n;
for (int i = 0; i < (int)(n); ++i) {
cin >> a >> b;
v.push_back(make_pair(a, b));
}
sort(v.begin(), v.end());
long i = 0;
bool find = false;
while (i < n - 1 && !find) {
if (v[i].second > v[i + 1].second)
find = true;
else
i++;
}
if (find)
cout << "Happy Alex";
else
cout << "Poor Alex";
cout << endl;
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
The numbers of all offices in the new building of the Tax Office of IT City will have lucky numbers.
Lucky number is a number that consists of digits 7 and 8 only. Find the maximum number of offices in the new building of the Tax Office given that a door-plate can hold a number not longer than n digits.
Input
The only line of input contains one integer n (1 ≤ n ≤ 55) — the maximum length of a number that a door-plate can hold.
Output
Output one integer — the maximum number of offices, than can have unique lucky numbers not longer than n digits.
Examples
Input
2
Output
6
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
char _;
const int maxN = 80 + 5;
const int maxM = 5000 + 5;
const int mod = 1000 * 1000 * 1000 + 7;
const int base = 701;
const int SQ = 500;
const int maxL = 20;
long double x = 1.000000011;
long double power(long double n, int k) {
if (k == 0) return 1.0;
long double ans = power(n, k / 2);
ans = ans * ans;
if (k & 1) ans = ans * n;
return ans;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
cout << (1LL << (n + 1)) - 2 << endl;
return 0;
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
A maze is composed of a grid of H \times W squares - H vertical, W horizontal.
The square at the i-th row from the top and the j-th column from the left - (i,j) - is a wall if S_{ij} is `#` and a road if S_{ij} is `.`.
There is a magician in (C_h,C_w). He can do the following two kinds of moves:
* Move A: Walk to a road square that is vertically or horizontally adjacent to the square he is currently in.
* Move B: Use magic to warp himself to a road square in the 5\times 5 area centered at the square he is currently in.
In either case, he cannot go out of the maze.
At least how many times does he need to use the magic to reach (D_h, D_w)?
Constraints
* 1 \leq H,W \leq 10^3
* 1 \leq C_h,D_h \leq H
* 1 \leq C_w,D_w \leq W
* S_{ij} is `#` or `.`.
* S_{C_h C_w} and S_{D_h D_w} are `.`.
* (C_h,C_w) \neq (D_h,D_w)
Input
Input is given from Standard Input in the following format:
H W
C_h C_w
D_h D_w
S_{11}\ldots S_{1W}
\vdots
S_{H1}\ldots S_{HW}
Output
Print the minimum number of times the magician needs to use the magic. If he cannot reach (D_h,D_w), print `-1` instead.
Examples
Input
4 4
1 1
4 4
..#.
..#.
.#..
.#..
Output
1
Input
4 4
1 4
4 1
.##.
.##.
Output
-1
Input
4 4
2 2
3 3
....
....
....
....
Output
0
Input
4 5
1 2
2 5
.###
.
..##
..##
Output
2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int H,W,sx,sy,gx,gy,d[1000][1000];
string s[1000];
int INF=1<<30;
int main()
{
cin>>H>>W;
cin>>sx>>sy;
cin>>gx>>gy;
--sx;--sy;--gx;--gy;
for(int i=0;i<H;++i)cin>>s[i];
for(int i=0;i<H;++i)for(int j=0;j<W;++j)d[i][j]=INF;
d[sx][sy]=0;
deque<pair<int,int>>q;
q.push_back({sx,sy});
while(!q.empty())
{
int x=q.front().first;
int y=q.front().second;
q.pop_front();
for(int i=-2;i<=2;++i)for(int j=-2;j<=2;++j)
{
int nx=x+i;
int ny=y+j;
if(nx<0||ny<0||nx>=H||ny>=W||s[nx][ny]=='#')continue;
if(abs(i)+abs(j)<=1&&d[nx][ny]>d[x][y])
{
d[nx][ny]=d[x][y];
q.push_front({nx,ny});
}else if(d[nx][ny]>d[x][y]+1)
{
d[nx][ny]=d[x][y]+1;
q.push_back({nx,ny});
}
}
}
cout<<(d[gx][gy]==INF?-1:d[gx][gy])<<endl;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
In this problem we consider a special type of an auction, which is called the second-price auction. As in regular auction n bidders place a bid which is price a bidder ready to pay. The auction is closed, that is, each bidder secretly informs the organizer of the auction price he is willing to pay. After that, the auction winner is the participant who offered the highest price. However, he pay not the price he offers, but the highest price among the offers of other participants (hence the name: the second-price auction).
Write a program that reads prices offered by bidders and finds the winner and the price he will pay. Consider that all of the offered prices are different.
Input
The first line of the input contains n (2 ≤ n ≤ 1000) — number of bidders. The second line contains n distinct integer numbers p1, p2, ... pn, separated by single spaces (1 ≤ pi ≤ 10000), where pi stands for the price offered by the i-th bidder.
Output
The single output line should contain two integers: index of the winner and the price he will pay. Indices are 1-based.
Examples
Input
2
5 7
Output
2 5
Input
3
10 2 8
Output
1 8
Input
6
3 8 2 9 4 14
Output
6 9
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, t;
cin >> n;
long long int p[n], m[n];
for (long long int i = 0; i < n; i++) {
cin >> p[i];
m[i] = p[i];
}
sort(m, m + n, greater<int>());
for (long long int i = 0; i < n; i++) {
if (m[0] == p[i]) {
t = i + 1;
break;
}
}
cout << t << " " << m[1];
return 0;
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
Vasya has n days of vacations! So he decided to improve his IT skills and do sport. Vasya knows the following information about each of this n days: whether that gym opened and whether a contest was carried out in the Internet on that day. For the i-th day there are four options:
1. on this day the gym is closed and the contest is not carried out;
2. on this day the gym is closed and the contest is carried out;
3. on this day the gym is open and the contest is not carried out;
4. on this day the gym is open and the contest is carried out.
On each of days Vasya can either have a rest or write the contest (if it is carried out on this day), or do sport (if the gym is open on this day).
Find the minimum number of days on which Vasya will have a rest (it means, he will not do sport and write the contest at the same time). The only limitation that Vasya has — he does not want to do the same activity on two consecutive days: it means, he will not do sport on two consecutive days, and write the contest on two consecutive days.
Input
The first line contains a positive integer n (1 ≤ n ≤ 100) — the number of days of Vasya's vacations.
The second line contains the sequence of integers a1, a2, ..., an (0 ≤ ai ≤ 3) separated by space, where:
* ai equals 0, if on the i-th day of vacations the gym is closed and the contest is not carried out;
* ai equals 1, if on the i-th day of vacations the gym is closed, but the contest is carried out;
* ai equals 2, if on the i-th day of vacations the gym is open and the contest is not carried out;
* ai equals 3, if on the i-th day of vacations the gym is open and the contest is carried out.
Output
Print the minimum possible number of days on which Vasya will have a rest. Remember that Vasya refuses:
* to do sport on any two consecutive days,
* to write the contest on any two consecutive days.
Examples
Input
4
1 3 2 0
Output
2
Input
7
1 3 3 2 1 2 3
Output
0
Input
2
2 2
Output
1
Note
In the first test Vasya can write the contest on the day number 1 and do sport on the day number 3. Thus, he will have a rest for only 2 days.
In the second test Vasya should write contests on days number 1, 3, 5 and 7, in other days do sport. Thus, he will not have a rest for a single day.
In the third test Vasya can do sport either on a day number 1 or number 2. He can not do sport in two days, because it will be contrary to the his limitation. Thus, he will have a rest for only one day.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int rest = 0;
int gym = 0;
int contest = 0;
int main() {
int n;
int type;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> type;
if (type == 0) {
gym = 0;
contest = 0;
rest++;
} else if (type == 1) {
if (contest == 0) {
gym = 0;
contest = 1;
} else {
gym = 0;
contest = 0;
rest++;
}
} else if (type == 2) {
if (gym == 0) {
gym = 1;
contest = 0;
} else {
gym = 0;
contest = 0;
rest++;
}
} else if (type == 3) {
if (gym == 1 && contest == 0) {
gym = 0;
contest = 1;
} else if (gym == 0 && contest == 1) {
gym = 1;
contest = 0;
} else {
gym = 0;
contest = 0;
}
}
}
cout << rest << endl;
return 0;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
A sequence of non-negative integers a1, a2, ..., an of length n is called a wool sequence if and only if there exists two integers l and r (1 ≤ l ≤ r ≤ n) such that <image>. In other words each wool sequence contains a subsequence of consecutive elements with xor equal to 0.
The expression <image> means applying the operation of a bitwise xor to numbers x and y. The given operation exists in all modern programming languages, for example, in languages C++ and Java it is marked as "^", in Pascal — as "xor".
In this problem you are asked to compute the number of sequences made of n integers from 0 to 2m - 1 that are not a wool sequence. You should print this number modulo 1000000009 (109 + 9).
Input
The only line of input contains two space-separated integers n and m (1 ≤ n, m ≤ 105).
Output
Print the required number of sequences modulo 1000000009 (109 + 9) on the only line of output.
Examples
Input
3 2
Output
6
Note
Sequences of length 3 made of integers 0, 1, 2 and 3 that are not a wool sequence are (1, 3, 1), (1, 2, 1), (2, 1, 2), (2, 3, 2), (3, 1, 3) and (3, 2, 3).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long n, m, q, r;
long long pw(long long a, long long b) {
if (b == 0) return 1;
if (b % 2) return a * pw(a, b - 1) % 1000000009;
return pw(a * a % 1000000009, b / 2);
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m;
q = pw(2, m);
q = q - 1 + 1000000009;
q %= 1000000009;
r = 1;
for (int i = 1; i <= n; i++) {
r = r * (q - i + 1000000009 + 1) % 1000000009;
}
cout << r << endl;
cin.get();
cin.get();
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
Petya recently found a game "Choose a Square". In this game, there are n points numbered from 1 to n on an infinite field. The i-th point has coordinates (x_i, y_i) and cost c_i.
You have to choose a square such that its sides are parallel to coordinate axes, the lower left and upper right corners belong to the line y = x, and all corners have integer coordinates.
The score you get is the sum of costs of the points covered by the selected square minus the length of the side of the square. Note that the length of the side can be zero.
Petya asks you to calculate the maximum possible score in the game that can be achieved by placing exactly one square.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 5 ⋅ 10^5) — the number of points on the field.
Each of the following n lines contains three integers x_i, y_i, c_i (0 ≤ x_i, y_i ≤ 10^9, -10^6 ≤ c_i ≤ 10^6) — coordinates of the i-th point and its cost, respectively.
Output
In the first line print the maximum score Petya can achieve.
In the second line print four integers x_1, y_1, x_2, y_2 (0 ≤ x_1, y_1, x_2, y_2 ≤ 2 ⋅ 10^9, x_1 = y_1, x_2 = y_2, x_1 ≤ x_2) separated by spaces — the coordinates of the lower left and upper right corners of the square which Petya has to select in order to achieve the maximum score.
Examples
Input
6
0 0 2
1 0 -5
1 1 3
2 3 4
1 4 -4
3 1 -1
Output
4
1 1 3 3
Input
5
3 3 0
3 3 -3
0 2 -1
3 1 3
0 0 -2
Output
0
1 1 1 1
Note
The field corresponding to the first example: <image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
long long int c[N], lzy[6 * N], n, x[N], y[N], sz = 0, m2[N];
map<long long int, long long int> m1;
pair<long long int, long long int> tree[6 * N];
vector<pair<long long int, long long int> > v[N];
void build(int lo, int hi, int i) {
if (lo == hi) {
tree[i] = {0, lo};
return;
}
int mid = (lo + hi) / 2;
build(lo, mid, 2 * i);
build(mid + 1, hi, 2 * i + 1);
tree[i] = max(tree[2 * i], tree[2 * i + 1]);
}
void update(int lo, int hi, int l, int r, long long int cost, int i) {
if (lo > r || hi < l) return;
if (lzy[i]) {
if (lo != hi) {
tree[2 * i].first += lzy[i];
tree[2 * i + 1].first += lzy[i];
lzy[2 * i] += lzy[i];
lzy[2 * i + 1] += lzy[i];
}
lzy[i] = 0;
}
if (lo >= l && hi <= r) {
tree[i].first += cost;
lzy[i] += cost;
return;
}
int mid = (lo + hi) / 2;
update(lo, mid, l, r, cost, 2 * i);
update(mid + 1, hi, l, r, cost, 2 * i + 1);
tree[i] = max(tree[2 * i], tree[2 * i + 1]);
}
pair<long long int, long long int> query(int lo, int hi, int l, int r, int i) {
if (lo > r || hi < l) return {-1e18, 0};
if (lzy[i]) {
if (lo != hi) {
tree[2 * i].first += lzy[i];
tree[2 * i + 1].first += lzy[i];
lzy[2 * i] += lzy[i];
lzy[2 * i + 1] += lzy[i];
}
lzy[i] = 0;
}
if (lo >= l && hi <= r) {
return tree[i];
}
int mid = (lo + hi) / 2;
return max(query(lo, mid, l, r, 2 * i), query(mid + 1, hi, l, r, 2 * i + 1));
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 0; i <= n - 1; i++) {
cin >> x[i] >> y[i] >> c[i];
if (x[i] > y[i]) swap(x[i], y[i]);
m1[x[i]], m1[y[i]];
}
for (__typeof(m1.begin()) it = m1.begin(); it != m1.end(); it++) {
sz++;
m1[it->first] = sz;
m2[sz] = it->first;
}
for (int i = 0; i <= n - 1; i++) {
v[m1[x[i]]].push_back(make_pair(m1[y[i]], c[i]));
}
build(1, sz, 1);
for (int i = 1; i <= sz; i++) {
update(1, sz, i, i, -m2[i], 1);
}
long long int ans = 0;
pair<long long int, long long int> p = {1e9 + 7, 1e9 + 7};
for (int i = sz; i >= 1; i--) {
for (__typeof(v[i].begin()) it = v[i].begin(); it != v[i].end(); it++) {
long long int y = (it->first), cst = (it->second);
update(1, sz, y, sz, cst, 1);
}
pair<long long int, long long int> q = query(1, sz, i, sz, 1);
if (q.first + m2[i] > ans) {
ans = q.first + m2[i];
p.first = m2[i], p.second = m2[q.second];
}
}
cout << ans;
cout << "\n";
cout << p.first << " " << p.first;
cout << " ";
cout << p.second << " " << p.second;
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
As the guys fried the radio station facilities, the school principal gave them tasks as a punishment. Dustin's task was to add comments to nginx configuration for school's website. The school has n servers. Each server has a name and an ip (names aren't necessarily unique, but ips are). Dustin knows the ip and name of each server. For simplicity, we'll assume that an nginx command is of form "command ip;" where command is a string consisting of English lowercase letter only, and ip is the ip of one of school servers.
<image>
Each ip is of form "a.b.c.d" where a, b, c and d are non-negative integers less than or equal to 255 (with no leading zeros). The nginx configuration file Dustin has to add comments to has m commands. Nobody ever memorizes the ips of servers, so to understand the configuration better, Dustin has to comment the name of server that the ip belongs to at the end of each line (after each command). More formally, if a line is "command ip;" Dustin has to replace it with "command ip; #name" where name is the name of the server with ip equal to ip.
Dustin doesn't know anything about nginx, so he panicked again and his friends asked you to do his task for him.
Input
The first line of input contains two integers n and m (1 ≤ n, m ≤ 1000).
The next n lines contain the names and ips of the servers. Each line contains a string name, name of the server and a string ip, ip of the server, separated by space (1 ≤ |name| ≤ 10, name only consists of English lowercase letters). It is guaranteed that all ip are distinct.
The next m lines contain the commands in the configuration file. Each line is of form "command ip;" (1 ≤ |command| ≤ 10, command only consists of English lowercase letters). It is guaranteed that ip belongs to one of the n school servers.
Output
Print m lines, the commands in the configuration file after Dustin did his task.
Examples
Input
2 2
main 192.168.0.2
replica 192.168.0.1
block 192.168.0.1;
proxy 192.168.0.2;
Output
block 192.168.0.1; #replica
proxy 192.168.0.2; #main
Input
3 5
google 8.8.8.8
codeforces 212.193.33.27
server 138.197.64.57
redirect 138.197.64.57;
block 8.8.8.8;
cf 212.193.33.27;
unblock 8.8.8.8;
check 138.197.64.57;
Output
redirect 138.197.64.57; #server
block 8.8.8.8; #google
cf 212.193.33.27; #codeforces
unblock 8.8.8.8; #google
check 138.197.64.57; #server
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
map<string, string> mp;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
string x, y;
cin >> x >> y;
y += ";";
mp[y] = x;
}
for (int i = 0; i < m; i++) {
string x, y;
cin >> x >> y;
cout << x << " " << y << " #" << mp[y] << endl;
}
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
A monopole magnet is a magnet that only has one pole, either north or south. They don't actually exist since real magnets have two poles, but this is a programming contest problem, so we don't care.
There is an n× m grid. Initially, you may place some north magnets and some south magnets into the cells. You are allowed to place as many magnets as you like, even multiple in the same cell.
An operation is performed as follows. Choose a north magnet and a south magnet to activate. If they are in the same row or the same column and they occupy different cells, then the north magnet moves one unit closer to the south magnet. Otherwise, if they occupy the same cell or do not share a row or column, then nothing changes. Note that the south magnets are immovable.
Each cell of the grid is colored black or white. Let's consider ways to place magnets in the cells so that the following conditions are met.
1. There is at least one south magnet in every row and every column.
2. If a cell is colored black, then it is possible for a north magnet to occupy this cell after some sequence of operations from the initial placement.
3. If a cell is colored white, then it is impossible for a north magnet to occupy this cell after some sequence of operations from the initial placement.
Determine if it is possible to place magnets such that these conditions are met. If it is possible, find the minimum number of north magnets required (there are no requirements on the number of south magnets).
Input
The first line contains two integers n and m (1≤ n,m≤ 1000) — the number of rows and the number of columns, respectively.
The next n lines describe the coloring. The i-th of these lines contains a string of length m, where the j-th character denotes the color of the cell in row i and column j. The characters "#" and "." represent black and white, respectively. It is guaranteed, that the string will not contain any other characters.
Output
Output a single integer, the minimum possible number of north magnets required.
If there is no placement of magnets that satisfies all conditions, print a single integer -1.
Examples
Input
3 3
.#.
###
##.
Output
1
Input
4 2
##
.#
.#
##
Output
-1
Input
4 5
....#
####.
.###.
.#...
Output
2
Input
2 1
.
#
Output
-1
Input
3 5
.....
.....
.....
Output
0
Note
In the first test, here is an example placement of magnets:
<image>
In the second test, we can show that no required placement of magnets exists. Here are three example placements that fail to meet the requirements. The first example violates rule 3 since we can move the north magnet down onto a white square. The second example violates rule 2 since we cannot move the north magnet to the bottom-left black square by any sequence of operations. The third example violates rule 1 since there is no south magnet in the first column.
<image>
In the third test, here is an example placement of magnets. We can show that there is no required placement of magnets with fewer north magnets.
<image>
In the fourth test, we can show that no required placement of magnets exists. Here are two example placements that fail to meet the requirements. The first example violates rule 1 since there is no south magnet in the first row. The second example violates rules 1 and 3 since there is no south magnet in the second row and we can move the north magnet up one unit onto a white square.
<image>
In the fifth test, we can put the south magnet in each cell and no north magnets. Because there are no black cells, it will be a correct placement.
### Response
```cpp
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimization("O2")
#pragma GCC optimization("unroll-loops")
using namespace std;
short n, m;
string s[1001];
vector<short> b_hor[1001], b_ver[1001];
vector<pair<short, short> > g[1001][1001];
bool used[1001][1001];
void dfs(pair<int, int> u) {
used[u.first][u.second] = 1;
for (auto v : g[u.first][u.second]) {
if (!used[v.first][v.second]) dfs(v);
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
for (int i = 0; i < n; ++i) {
cin >> s[i];
for (int j = 0; j < m; ++j) {
if (s[i][j] == '#') {
b_hor[i].push_back(j);
b_ver[j].push_back(i);
if (i && s[i - 1][j] == '#') {
g[i][j].push_back(make_pair(i - 1, j));
g[i - 1][j].push_back(make_pair(i, j));
}
if (j && s[i][j - 1] == '#') {
g[i][j].push_back(make_pair(i, j - 1));
g[i][j - 1].push_back(make_pair(i, j));
}
}
}
}
bool fucked = 0, w_hor = 0, w_ver = 0;
for (int i = 0; i < n; ++i) {
if (b_hor[i].empty()) {
w_hor = 1;
continue;
}
for (int j = 0; j < int(b_hor[i].size()) - 1; ++j) {
if (b_hor[i][j + 1] - b_hor[i][j] > 1) fucked = 1;
}
}
for (int j = 0; j < m; ++j) {
if (b_ver[j].empty()) {
w_ver = 1;
continue;
}
for (int i = 0; i < int(b_ver[j].size()) - 1; ++i) {
if (b_ver[j][i + 1] - b_ver[j][i] > 1) fucked = 1;
}
}
if (fucked || (w_hor ^ w_ver))
cout << "-1\n";
else {
int ans = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (s[i][j] == '#' && !used[i][j]) {
dfs(make_pair(i, j));
++ans;
}
}
}
cout << ans << '\n';
}
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
Petya loves lucky numbers very much. Everybody knows that lucky numbers are positive integers whose decimal record contains only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Petya has sequence a consisting of n integers.
The subsequence of the sequence a is such subsequence that can be obtained from a by removing zero or more of its elements.
Two sequences are considered different if index sets of numbers included in them are different. That is, the values of the elements do not matter in the comparison of subsequences. In particular, any sequence of length n has exactly 2n different subsequences (including an empty subsequence).
A subsequence is considered lucky if it has a length exactly k and does not contain two identical lucky numbers (unlucky numbers can be repeated any number of times).
Help Petya find the number of different lucky subsequences of the sequence a. As Petya's parents don't let him play with large numbers, you should print the result modulo prime number 1000000007 (109 + 7).
Input
The first line contains two integers n and k (1 ≤ k ≤ n ≤ 105). The next line contains n integers ai (1 ≤ ai ≤ 109) — the sequence a.
Output
On the single line print the single number — the answer to the problem modulo prime number 1000000007 (109 + 7).
Examples
Input
3 2
10 10 10
Output
3
Input
4 2
4 4 7 7
Output
4
Note
In the first sample all 3 subsequences of the needed length are considered lucky.
In the second sample there are 4 lucky subsequences. For them the sets of indexes equal (the indexation starts from 1): {1, 3}, {1, 4}, {2, 3} and {2, 4}.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long dp[2100][2100];
int use[3010], id[100010];
long long fac[100010];
map<int, int> ss;
const long long MOD = 1000000007LL;
bool lucky(int num) {
while (num != 0) {
if (num % 10 != 4 && num % 10 != 7) return false;
num /= 10;
}
return true;
}
long long exp(int a, int b) {
long long ans = 1, num = a;
while (b != 0) {
if (b % 2 == 1) ans = (ans * num) % MOD;
num = (num * num) % MOD;
b = b / 2;
}
return ans;
}
long long c(int a, int b) {
if (a < b) return 0;
long long ans = fac[a];
ans = (ans * exp(fac[b], MOD - 2)) % MOD;
ans = (ans * exp(fac[a - b], MOD - 2)) % MOD;
return ans;
}
int a[100010];
int main() {
fac[0] = 1;
for (int i = 1; i <= 100000; i++) {
fac[i] = (fac[i - 1] * i) % MOD;
}
int n, k;
while (scanf("%d%d", &n, &k) == 2) {
int cnt = 0, others = 0;
ss.clear();
memset(use, 0, sizeof(use));
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
if (lucky(a[i])) {
if (ss.find(a[i]) == ss.end()) {
cnt++;
ss[a[i]] = cnt - 1;
id[i] = cnt - 1;
use[cnt - 1]++;
} else {
id[i] = ss[a[i]];
use[ss[a[i]]]++;
}
} else
others++;
}
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
for (int i = 1; i <= cnt; i++) {
for (int j = 0; j <= i; j++) {
dp[i][j] = dp[i - 1][j];
if (j != 0) dp[i][j] += (dp[i - 1][j - 1] * use[i - 1]) % MOD;
dp[i][j] %= MOD;
}
}
long long ans = 0;
for (int i = 0; i <= k && i <= cnt; i++) {
long long tnum = dp[cnt][i];
tnum = (tnum * c(others, k - i)) % MOD;
ans = (ans + tnum) % MOD;
}
printf("%I64d\n", ans);
}
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
There are N observatories in AtCoder Hill, called Obs. 1, Obs. 2, ..., Obs. N. The elevation of Obs. i is H_i. There are also M roads, each connecting two different observatories. Road j connects Obs. A_j and Obs. B_j.
Obs. i is said to be good when its elevation is higher than those of all observatories that can be reached from Obs. i using just one road. Note that Obs. i is also good when no observatory can be reached from Obs. i using just one road.
How many good observatories are there?
Constraints
* 2 \leq N \leq 10^5
* 1 \leq M \leq 10^5
* 1 \leq H_i \leq 10^9
* 1 \leq A_i,B_i \leq N
* A_i \neq B_i
* Multiple roads may connect the same pair of observatories.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
H_1 H_2 ... H_N
A_1 B_1
A_2 B_2
:
A_M B_M
Output
Print the number of good observatories.
Examples
Input
4 3
1 2 3 4
1 3
2 3
2 4
Output
2
Input
6 5
8 6 9 1 2 1
1 3
4 2
4 3
4 6
4 6
Output
3
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int n,m,h[100010],a,b,f[100010],ans;
vector<int> v[100010];
int main(){
cin>>n>>m;
for (int i=1;i<=n;i++) cin>>h[i];
for (int i=0;i<m;i++){
cin>>a>>b;
if (h[a]>=h[b]) f[b]=1;
if (h[a]<=h[b]) f[a]=1;
}
for (int i=1;i<=n;i++) if (f[i]==0) ans++;
cout<<ans<<endl;
return 0;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
A Martian boy is named s — he has got this name quite recently from his parents for his coming of age birthday. Now he enjoys looking for his name everywhere. If he sees that he can obtain his name from some string by removing zero or more letters (at that, the remaining letters remain in the same order), he gets happy. For example, if s=«aba», then strings «baobab», «aabbaa», «helloabahello» make him very happy and strings «aab», «baaa» and «helloabhello» do not.
However rather than being happy once, he loves twice as much being happy twice! So, when he got string t as a present, he wanted to cut it in two parts (the left part and the right part) so that each part made him happy.
Help s determine the number of distinct ways to cut the given string t into two parts in the required manner.
Input
The first line contains string s, consisting of lowercase English letters. The length of string s is from 1 to 1000 letters.
The second line contains string t, that also consists of lowercase English letters. The length of string t is from 1 to 106 letters.
Output
Print the sought number of ways to cut string t in two so that each part made s happy.
Examples
Input
aba
baobababbah
Output
2
Input
mars
sunvenusearthmarsjupitersaturnuranusneptune
Output
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string s1, s2;
cin >> s1 >> s2;
int rposs = 0, r = 0;
int lposs = 0, l = s1.size() - 1;
for (int i = 0; i < s2.size(); ++i) {
if (r < s1.size() && s2[i] == s1[r]) {
++r;
rposs = i;
}
if (l >= 0 && s2[s2.size() - 1 - i] == s1[l]) {
--l;
lposs = s2.size() - 1 - i;
}
}
if (r == s1.size() && l == -1 && rposs <= lposs) {
cout << lposs - rposs;
return 0;
}
cout << 0;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
Given is an integer S. Find how many sequences there are whose terms are all integers greater than or equal to 3, and whose sum is equal to S. The answer can be very large, so output it modulo 10^9 + 7.
Constraints
* 1 \leq S \leq 2000
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
S
Output
Print the answer.
Examples
Input
7
Output
3
Input
2
Output
0
Input
1729
Output
294867501
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int s;
cin >> s;
vector<long long> dp(2001,0);
dp[0]=1;
for(int i=3;i<2001;i++){
for(int j=0;j<=i-3;j++){
dp[i]=(dp[i]+dp[j])%1000000007;
}
}
cout << dp[s] << endl;
return 0;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
You're given an array a of length 2n. Is it possible to reorder it in such way so that the sum of the first n elements isn't equal to the sum of the last n elements?
Input
The first line contains an integer n (1 ≤ n ≤ 1000), where 2n is the number of elements in the array a.
The second line contains 2n space-separated integers a_1, a_2, …, a_{2n} (1 ≤ a_i ≤ 10^6) — the elements of the array a.
Output
If there's no solution, print "-1" (without quotes). Otherwise, print a single line containing 2n space-separated integers. They must form a reordering of a. You are allowed to not change the order.
Examples
Input
3
1 2 2 1 3 1
Output
2 1 3 1 1 2
Input
1
1 1
Output
-1
Note
In the first example, the first n elements have sum 2+1+3=6 while the last n elements have sum 1+1+2=4. The sums aren't equal.
In the second example, there's no solution.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 1000, M = 50, MOD = 1e9 + 9, Sqrt = 500;
const int OO = 1e5 + 1;
int a[N];
int n;
int main() {
cin >> n;
for (int i = 1; i <= 2 * n; ++i) cin >> a[i];
sort(a + 1, a + 1 + 2 * n, greater<int>());
long long sum = 0;
for (int i = 1; i <= n; ++i) sum += a[i];
for (int i = n + 1; i <= 2 * n; ++i) sum -= a[i];
if (sum == 0) {
return cout << "-1" << endl, 0;
}
for (int i = 1; i <= 2 * n; ++i) cout << a[i] << " ";
cout << endl;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
Petya is preparing for IQ test and he has noticed that there many problems like: you are given a sequence, find the next number. Now Petya can solve only problems with arithmetic or geometric progressions.
Arithmetic progression is a sequence a1, a1 + d, a1 + 2d, ..., a1 + (n - 1)d, where a1 and d are any numbers.
Geometric progression is a sequence b1, b2 = b1q, ..., bn = bn - 1q, where b1 ≠ 0, q ≠ 0, q ≠ 1.
Help Petya and write a program to determine if the given sequence is arithmetic or geometric. Also it should found the next number. If the sequence is neither arithmetic nor geometric, print 42 (he thinks it is impossible to find better answer). You should also print 42 if the next element of progression is not integer. So answer is always integer.
Input
The first line contains exactly four integer numbers between 1 and 1000, inclusively.
Output
Print the required number. If the given sequence is arithmetic progression, print the next progression element. Similarly, if the given sequence is geometric progression, print the next progression element.
Print 42 if the given sequence is not an arithmetic or geometric progression.
Examples
Input
836 624 412 200
Output
-12
Input
1 334 667 1000
Output
1333
Note
This problem contains very weak pretests!
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
double nums[4];
double d, q;
for (int i = 0; i < 4; i++) cin >> nums[i];
d = nums[1] - nums[0];
q = nums[1] / nums[0];
if (nums[2] == nums[1] + d && nums[3] == nums[2] + d) {
if (static_cast<int>(nums[3] + d) == (nums[3] + d))
cout << nums[3] + d << endl;
else
cout << 42 << endl;
} else if (nums[2] == nums[1] * q && nums[3] == nums[2] * q) {
if (static_cast<int>(nums[3] * q) == (nums[3] * q))
cout << nums[3] * q << endl;
else
cout << 42 << endl;
} else {
cout << 42 << endl;
}
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
To learn as soon as possible the latest news about their favourite fundamentally new operating system, BolgenOS community from Nizhni Tagil decided to develop a scheme. According to this scheme a community member, who is the first to learn the news, calls some other member, the latter, in his turn, calls some third member, and so on; i.e. a person with index i got a person with index fi, to whom he has to call, if he learns the news. With time BolgenOS community members understood that their scheme doesn't work sometimes — there were cases when some members didn't learn the news at all. Now they want to supplement the scheme: they add into the scheme some instructions of type (xi, yi), which mean that person xi has to call person yi as well. What is the minimum amount of instructions that they need to add so, that at the end everyone learns the news, no matter who is the first to learn it?
Input
The first input line contains number n (2 ≤ n ≤ 105) — amount of BolgenOS community members. The second line contains n space-separated integer numbers fi (1 ≤ fi ≤ n, i ≠ fi) — index of a person, to whom calls a person with index i.
Output
In the first line output one number — the minimum amount of instructions to add. Then output one of the possible variants to add these instructions into the scheme, one instruction in each line. If the solution is not unique, output any.
Examples
Input
3
3 3 2
Output
1
3 1
Input
7
2 3 1 3 4 4 1
Output
3
2 5
2 6
3 7
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using vi = vector<int>;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
vector<int> f(n), cnt(n, 0);
vector<bool> vis(n, false);
vector<int> head, tail;
for (int& e : f) {
cin >> e, e--;
cnt[e]++;
}
for (int i = 0; i < n; i++) {
if (cnt[i] || vis[i]) continue;
int j = i;
while (!vis[j]) {
vis[j] = true;
j = f[j];
}
head.emplace_back(i + 1), tail.emplace_back(j + 1);
}
for (int i = 0; i < n; i++) {
if (vis[i]) continue;
int j = i;
while (!vis[j]) {
vis[j] = true;
j = f[j];
}
head.emplace_back(i + 1), tail.emplace_back(j + 1);
};
int m = head.size();
if (m == 1 && head[0] == tail[0]) {
cout << "0\n";
return 0;
}
cout << m << '\n';
for (int i = 0; i < m; i++)
cout << tail[i] << ' ' << head[(i + 1) % m] << '\n';
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
During one of the space missions, humans have found an evidence of previous life at one of the planets. They were lucky enough to find a book with birth and death years of each individual that had been living at this planet. What's interesting is that these years are in the range (1, 10^9)! Therefore, the planet was named Longlifer.
In order to learn more about Longlifer's previous population, scientists need to determine the year with maximum number of individuals that were alive, as well as the number of alive individuals in that year. Your task is to help scientists solve this problem!
Input
The first line contains an integer n (1 ≤ n ≤ 10^5) — the number of people.
Each of the following n lines contain two integers b and d (1 ≤ b < d ≤ 10^9) representing birth and death year (respectively) of each individual.
Output
Print two integer numbers separated by blank character, y — the year with a maximum number of people alive and k — the number of people alive in year y.
In the case of multiple possible solutions, print the solution with minimum year.
Examples
Input
3
1 5
2 4
5 6
Output
2 2
Input
4
3 4
4 5
4 6
8 10
Output
4 2
Note
You can assume that an individual living from b to d has been born at the beginning of b and died at the beginning of d, and therefore living for d - b years.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int n = 0, f = 1, ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
n = n * 10 + ch - '0';
ch = getchar();
}
return n * f;
}
struct sth {
int t, j;
} a[800004];
bool bi(struct sth x, struct sth y) {
if (x.t != y.t)
return x.t < y.t;
else
return x.j < y.j;
}
int main() {
int n, maxn = 0, now = 0, mpos = 0;
n = read();
for (int i = 1; i <= n; i++) {
a[2 * i - 1].t = read();
a[2 * i - 1].j = 1;
a[2 * i].t = read();
a[2 * i].j = -1;
}
sort(a + 1, a + 2 * n + 1, bi);
for (int i = 1; i <= 2 * n; i++) {
now += a[i].j;
if (now > maxn) {
maxn = now;
mpos = a[i].t;
}
}
printf("%d %d\n", mpos, maxn);
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
Do you remember a kind cartoon "Beauty and the Beast"? No, no, there was no firing from machine guns or radiation mutants time-travels!
There was a beauty named Belle. Once she had violated the Beast's order and visited the West Wing. After that she was banished from the castle...
Everybody was upset. The beautiful Belle was upset, so was the Beast, so was Lumiere the candlestick. But the worst thing was that Cogsworth was upset. Cogsworth is not a human, but is the mantel clock, which was often used as an alarm clock.
Due to Cogsworth's frustration all the inhabitants of the castle were in trouble: now they could not determine when it was time to drink morning tea, and when it was time for an evening stroll.
Fortunately, deep in the basement are lying digital clock showing the time in the format HH:MM. Now the residents of the castle face a difficult task. They should turn Cogsworth's hour and minute mustache hands in such a way, that Cogsworth began to show the correct time. Moreover they need to find turn angles in degrees for each mustache hands. The initial time showed by Cogsworth is 12:00.
You can only rotate the hands forward, that is, as is shown in the picture:
<image>
As since there are many ways too select such angles because of full rotations, choose the smallest angles in the right (non-negative) direction.
Note that Cogsworth's hour and minute mustache hands move evenly and continuously. Hands are moving independently, so when turning one hand the other hand remains standing still.
Input
The only line of input contains current time according to the digital clock, formatted as HH:MM (00 ≤ HH ≤ 23, 00 ≤ MM ≤ 59). The mantel clock initially shows 12:00.
Pretests contain times of the beginning of some morning TV programs of the Channel One Russia.
Output
Print two numbers x and y — the angles of turning the hour and minute hands, respectively (0 ≤ x, y < 360). The absolute or relative error in the answer should not exceed 10 - 9.
Examples
Input
12:00
Output
0 0
Input
04:30
Output
135 180
Input
08:17
Output
248.5 102
Note
A note to the second example: the hour hand will be positioned exactly in the middle, between 4 and 5.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int h, m, p;
double x, y;
scanf("%d:%d", &h, &m);
if (h > 11) h = h % 12;
p = h * 30;
x = p + (double)m / 2;
y = 6.0 * m;
printf("%lf %lf", x, y);
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
Takahashi and Aoki will play a game. They will repeatedly play it until one of them have N wins in total.
When they play the game once, Takahashi wins with probability A %, Aoki wins with probability B %, and the game ends in a draw (that is, nobody wins) with probability C %. Find the expected number of games that will be played, and print it as follows.
We can represent the expected value as P/Q with coprime integers P and Q. Print the integer R between 0 and 10^9+6 (inclusive) such that R \times Q \equiv P\pmod {10^9+7}. (Such an integer R always uniquely exists under the constraints of this problem.)
Constraints
* 1 \leq N \leq 100000
* 0 \leq A,B,C \leq 100
* 1 \leq A+B
* A+B+C=100
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N A B C
Output
Print the expected number of games that will be played, in the manner specified in the statement.
Examples
Input
1 25 25 50
Output
2
Input
4 50 50 0
Output
312500008
Input
1 100 0 0
Output
1
Input
100000 31 41 28
Output
104136146
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
constexpr long long MOD = 1e9 + 7;
constexpr int MAX_N = 200000 + 1;
long long fact[MAX_N];
void init_fact() {
fact[0] = 1;
for(auto i = 1; i < MAX_N; ++i)
fact[i] = fact[i-1] * i % MOD;
}
long long pow_mod(long long x, long long y, long long mod) {
auto ret=1ll;
while (y) {
if (y % 2)
ret = ret * x % mod;
x = x * x % mod;
y /= 2;
}
return ret;
}
long long nCr(int n, int r) {
return fact[n] * pow_mod(fact[n-r], MOD - 2, MOD) % MOD * pow_mod(fact[r], MOD - 2, MOD) % MOD;
}
void solve()
{
init_fact();
int N, A, B, C;
cin >> N >> A >> B >> C;
long long ans = 0;
long long dab = pow_mod(A + B, MOD - 2, MOD);
for(auto i = N; i < 2 * N; ++i)
{
ans += nCr(i - 1, N - 1)
* (pow_mod(A, N, MOD) * pow_mod(B, i - N, MOD) % MOD + pow_mod(A, i - N, MOD) * pow_mod(B, N, MOD) % MOD) % MOD
* i % MOD
* 100 % MOD
* pow_mod(dab, i, MOD) % MOD
* pow_mod(100 - C, MOD - 2, MOD) % MOD;
ans %= MOD;
}
cout << ans << endl;
}
int main()
{
cin.sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
solve();
}
``` |
### Prompt
Please formulate 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, c, d, i, j, x, y, k, m, n;
while (cin >> a >> b >> c >> d) {
while (1) {
a = a - 1;
if (a < 0) {
cout << "Second" << endl;
break;
}
b = b - 1;
if (b < 0) {
cout << "First" << endl;
break;
}
}
}
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
Petya started to attend programming lessons. On the first lesson his task was to write a simple program. The program was supposed to do the following: in the given string, consisting if uppercase and lowercase Latin letters, it:
* deletes all the vowels,
* inserts a character "." before each consonant,
* replaces all uppercase consonants with corresponding lowercase ones.
Vowels are letters "A", "O", "Y", "E", "U", "I", and the rest are consonants. The program's input is exactly one string, it should return the output as a single string, resulting after the program's processing the initial string.
Help Petya cope with this easy task.
Input
The first line represents input string of Petya's program. This string only consists of uppercase and lowercase Latin letters and its length is from 1 to 100, inclusive.
Output
Print the resulting string. It is guaranteed that this string is not empty.
Examples
Input
tour
Output
.t.r
Input
Codeforces
Output
.c.d.f.r.c.s
Input
aBAcAba
Output
.b.c.b
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
string s;
cin >> s;
int n = s.size();
int i;
for (i = 0; i < n; ++i) {
if (s[i] == 'A' || s[i] == 'a' || s[i] == 'E' || s[i] == 'e' ||
s[i] == 'I' || s[i] == 'i' || s[i] == 'O' || s[i] == 'o' ||
s[i] == 'U' || s[i] == 'u' || s[i] == 'Y' || s[i] == 'y')
continue;
else if (s[i] >= 65 && s[i] <= 90) {
s[i] += 32;
cout << "." << s[i];
} else
cout << "." << s[i];
}
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
The country Treeland consists of n cities connected with n - 1 bidirectional roads in such a way that it's possible to reach every city starting from any other city using these roads. There will be a soccer championship next year, and all participants are Santa Clauses. There are exactly 2k teams from 2k different cities.
During the first stage all teams are divided into k pairs. Teams of each pair play two games against each other: one in the hometown of the first team, and the other in the hometown of the other team. Thus, each of the 2k cities holds exactly one soccer game. However, it's not decided yet how to divide teams into pairs.
It's also necessary to choose several cities to settle players in. Organizers tend to use as few cities as possible to settle the teams.
Nobody wants to travel too much during the championship, so if a team plays in cities u and v, it wants to live in one of the cities on the shortest path between u and v (maybe, in u or in v). There is another constraint also: the teams from one pair must live in the same city.
Summarizing, the organizers want to divide 2k teams into pairs and settle them in the minimum possible number of cities m in such a way that teams from each pair live in the same city which lies between their hometowns.
Input
The first line of input contains two integers n and k (2 ≤ n ≤ 2·105, 2 ≤ 2k ≤ n) — the number of cities in Treeland and the number of pairs of teams, respectively.
The following n - 1 lines describe roads in Treeland: each of these lines contains two integers a and b (1 ≤ a, b ≤ n, a ≠ b) which mean that there is a road between cities a and b. It's guaranteed that there is a path between any two cities.
The last line contains 2k distinct integers c1, c2, ..., c2k (1 ≤ ci ≤ n), where ci is the hometown of the i-th team. All these numbers are distinct.
Output
The first line of output must contain the only positive integer m which should be equal to the minimum possible number of cities the teams can be settled in.
The second line should contain m distinct numbers d1, d2, ..., dm (1 ≤ di ≤ n) denoting the indices of the cities where the teams should be settled.
The k lines should follow, the j-th of them should contain 3 integers uj, vj and xj, where uj and vj are the hometowns of the j-th pair's teams, and xj is the city they should live in during the tournament. Each of the numbers c1, c2, ..., c2k should occur in all uj's and vj's exactly once. Each of the numbers xj should belong to {d1, d2, ..., dm}.
If there are several possible answers, print any of them.
Example
Input
6 2
1 2
1 3
2 4
2 5
3 6
2 5 4 6
Output
1
2
5 4 2
6 2 2
Note
In the first test the orginizers can settle all the teams in the city number 2. The way to divide all teams into pairs is not important, since all requirements are satisfied anyway, because the city 2 lies on the shortest path between every two cities from {2, 4, 5, 6}.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<int> Edge[200001];
vector<int> Party[200001];
priority_queue<pair<int, int> > Q;
int N, K, C[200001], Visit[200001], Center, Size, Num;
int findCenter(int now) {
int i, j = Edge[now].size(), sum = 0, temp, ok = 1;
for (i = 0; i < j; i++) {
if (!Visit[Edge[now][i]]) {
Visit[Edge[now][i]] = 1;
temp = findCenter(Edge[now][i]);
sum += temp;
if (temp > K) ok = 0;
}
}
if (C[now]) sum++;
if (sum < K) ok = 0;
if (ok) Center = now;
return sum;
}
void makeParty(int now) {
int i, j = Edge[now].size();
for (i = 0; i < j; i++)
if (!Visit[Edge[now][i]]) {
Visit[Edge[now][i]] = 1;
if (C[Edge[now][i]]) Party[Num].push_back(Edge[now][i]);
makeParty(Edge[now][i]);
}
}
int main(void) {
int i, x, y;
scanf("%d %d", &N, &K);
for (i = 1; i < N; i++) {
scanf("%d %d", &x, &y);
Edge[x].push_back(y);
Edge[y].push_back(x);
}
for (i = 1; i <= 2 * K; i++) {
scanf("%d", &x);
C[x] = 1;
}
Visit[1] = 1;
x = findCenter(1);
for (i = 1; i <= N; i++) Visit[i] = 0;
printf("1\n%d\n", Center);
Visit[Center] = 1;
Size = Edge[Center].size();
for (i = 0; i < Size; i++) {
Num = i + 1;
Visit[Edge[Center][i]] = 1;
if (C[Edge[Center][i]]) Party[Num].push_back(Edge[Center][i]);
makeParty(Edge[Center][i]);
}
if (C[Center]) {
for (i = 1; i <= Size; i++) {
if (Party[i].size() < K) {
Party[i].push_back(Center);
break;
}
}
if (i == Size + 1) Party[++Size].push_back(Center);
}
for (i = 1; i <= Size; i++)
if (Party[i].size()) Q.push(make_pair(Party[i].size(), i));
while (!Q.empty()) {
x = Q.top().second;
Q.pop();
y = Q.top().second;
Q.pop();
printf("%d %d %d\n", Party[x].back(), Party[y].back(), Center);
Party[x].pop_back();
Party[y].pop_back();
if (Party[x].size()) Q.push(make_pair(Party[x].size(), x));
if (Party[y].size()) Q.push(make_pair(Party[y].size(), y));
}
return 0;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
Manao is taking part in a quiz. The quiz consists of n consecutive questions. A correct answer gives one point to the player. The game also has a counter of consecutive correct answers. When the player answers a question correctly, the number on this counter increases by 1. If the player answers a question incorrectly, the counter is reset, that is, the number on it reduces to 0. If after an answer the counter reaches the number k, then it is reset, and the player's score is doubled. Note that in this case, first 1 point is added to the player's score, and then the total score is doubled. At the beginning of the game, both the player's score and the counter of consecutive correct answers are set to zero.
Manao remembers that he has answered exactly m questions correctly. But he does not remember the order in which the questions came. He's trying to figure out what his minimum score may be. Help him and compute the remainder of the corresponding number after division by 1000000009 (109 + 9).
Input
The single line contains three space-separated integers n, m and k (2 ≤ k ≤ n ≤ 109; 0 ≤ m ≤ n).
Output
Print a single integer — the remainder from division of Manao's minimum possible score in the quiz by 1000000009 (109 + 9).
Examples
Input
5 3 2
Output
3
Input
5 4 2
Output
6
Note
Sample 1. Manao answered 3 questions out of 5, and his score would double for each two consecutive correct answers. If Manao had answered the first, third and fifth questions, he would have scored as much as 3 points.
Sample 2. Now Manao answered 4 questions. The minimum possible score is obtained when the only wrong answer is to the question 4.
Also note that you are asked to minimize the score and not the remainder of the score modulo 1000000009. For example, if Manao could obtain either 2000000000 or 2000000020 points, the answer is 2000000000 mod 1000000009, even though 2000000020 mod 1000000009 is a smaller number.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T Abs(T a) {
return a > 0 ? a : -a;
}
template <typename T>
inline T sqr(T a) {
return a * a;
}
template <typename T>
inline void relaxMin(T &a, T b) {
if (b < a) a = b;
}
template <typename T>
inline void relaxMax(T &a, T b) {
if (b > a) a = b;
}
const int INF = (int)1E9;
const long double EPS = 1E-9;
const long double PI = 3.1415926535897932384626433832795;
const int mod = 1000000009;
const int N2 = 2 * 2;
vector<long long> mult(vector<long long> a, vector<long long> b) {
vector<long long> c(N2);
c[0] = (a[0] * b[0] + a[1] * b[2]) % mod;
c[1] = (a[0] * b[1] + a[1] * b[3]) % mod;
c[2] = (a[2] * b[0] + a[3] * b[2]) % mod;
c[3] = (a[2] * b[1] + a[3] * b[3]) % mod;
return c;
}
vector<long long> pow(vector<long long> a, long long p) {
vector<long long> ans(N2);
ans[0] = ans[3] = 1;
ans[1] = ans[2] = 0;
while (p) {
if (p & 1) {
ans = mult(ans, a);
}
a = mult(a, a);
p >>= 1;
}
return ans;
}
void solve() {
long long n, m, k;
cin >> n >> m >> k;
long long w = n - m;
long long e = n / k;
long long e2 = max(0LL, e - w);
vector<long long> mm(4);
mm[0] = 2;
mm[1] = 2 * k;
mm[2] = 0;
mm[3] = 1;
vector<long long> ans = pow(mm, e2);
long long ans2 = ans[1];
n -= e2 * k;
ans2 += n - w;
ans2 %= mod;
cout << ans2 << endl;
}
int main() {
srand(time(0));
solve();
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
The squirrel Chokudai has N acorns. One day, he decides to do some trades in multiple precious metal exchanges to make more acorns.
His plan is as follows:
1. Get out of the nest with N acorns in his hands.
2. Go to Exchange A and do some trades.
3. Go to Exchange B and do some trades.
4. Go to Exchange A and do some trades.
5. Go back to the nest.
In Exchange X (X = A, B), he can perform the following operations any integer number of times (possibly zero) in any order:
* Lose g_{X} acorns and gain 1 gram of gold.
* Gain g_{X} acorns and lose 1 gram of gold.
* Lose s_{X} acorns and gain 1 gram of silver.
* Gain s_{X} acorns and lose 1 gram of silver.
* Lose b_{X} acorns and gain 1 gram of bronze.
* Gain b_{X} acorns and lose 1 gram of bronze.
Naturally, he cannot perform an operation that would leave him with a negative amount of acorns, gold, silver, or bronze.
What is the maximum number of acorns that he can bring to the nest? Note that gold, silver, or bronze brought to the nest would be worthless because he is just a squirrel.
Constraints
* 1 \leq N \leq 5000
* 1 \leq g_{X} \leq 5000
* 1 \leq s_{X} \leq 5000
* 1 \leq b_{X} \leq 5000
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
g_A s_A b_A
g_B s_B b_B
Output
Print the maximum number of acorns that Chokudai can bring to the nest.
Example
Input
23
1 1 1
2 1 1
Output
46
### Response
```cpp
#include <bits/stdc++.h>
#define rep(i,n) for(int i=(0);i<(n);i++)
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
template<class T> bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T> bool chmin(T &a, const T &b) { if (a>b) { a=b; return 1; } return 0; }
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
ll n;
cin >> n;
ll a[3];
rep(i, 3) cin >> a[i];
ll b[3];
rep(i, 3) cin >> b[i];
ll dp[n+1];
rep(i, 4) rep(j, n+1) dp[j] = 0;
dp[0] = n;
rep(i, 3){
rep(j, n+1) {
if(j-a[i] >= 0) chmax(dp[j], dp[j-a[i]] + b[i] - a[i]);
}
}
ll m = 0;
rep(j, n+1) chmax(m, dp[j]);
vector<ll> dp2(m+1, 0);
dp2[0] = m;
rep(i, 3){
rep(j, m+1){
if(j-b[i] >= 0) chmax(dp2[j], dp2[j-b[i]] + a[i] - b[i]);
}
}
ll ans = 0;
rep(j, m+1) chmax(ans, dp2[j]);
cout << ans << endl;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
Polycarp is writing the prototype of a graphic editor. He has already made up his mind that the basic image transformations in his editor will be: rotate the image 90 degrees clockwise, flip the image horizontally (symmetry relative to the vertical line, that is, the right part of the image moves to the left, and vice versa) and zooming on the image. He is sure that that there is a large number of transformations that can be expressed through these three.
He has recently stopped implementing all three transformations for monochrome images. To test this feature, he asked you to write a code that will consecutively perform three actions with a monochrome image: first it will rotate the image 90 degrees clockwise, then it will flip the image horizontally and finally, it will zoom in twice on the image (that is, it will double all the linear sizes).
Implement this feature to help Polycarp test his editor.
Input
The first line contains two integers, w and h (1 ≤ w, h ≤ 100) — the width and height of an image in pixels. The picture is given in h lines, each line contains w characters — each character encodes the color of the corresponding pixel of the image. The line consists only of characters "." and "*", as the image is monochrome.
Output
Print 2w lines, each containing 2h characters — the result of consecutive implementing of the three transformations, described above.
Examples
Input
3 2
.*.
.*.
Output
....
....
****
****
....
....
Input
9 20
**.......
****.....
******...
*******..
..******.
....****.
......***
*.....***
*********
*********
*********
*********
....**...
...****..
..******.
.********
****..***
***...***
**.....**
*.......*
Output
********......**********........********
********......**********........********
********........********......********..
********........********......********..
..********......********....********....
..********......********....********....
..********......********..********......
..********......********..********......
....********....****************........
....********....****************........
....********....****************........
....********....****************........
......******************..**********....
......******************..**********....
........****************....**********..
........****************....**********..
............************......**********
............************......**********
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long A = 100000000000000LL, N = 1000;
string st;
char a[N][N], c, b[N][N];
long long i, j, n, m;
int main() {
cin >> n >> m;
swap(n, m);
for (i = 0; i < n; i++)
for (j = 0; j < m; j++) cin >> a[i][j];
for (j = 0; j < m; j++)
for (i = n - 1; i >= 0; i--) b[j][n - i - 1] = a[i][j];
swap(n, m);
for (i = 0; i < n; i++) reverse(b[i], b[i] + m);
for (i = 0; i < n; i++) {
st = "";
for (j = 0; j < m; j++)
cout << b[i][j] << b[i][j], st += b[i][j], st += b[i][j];
cout << "\n" << st << "\n";
}
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
Example
Input
5
1 2
1 3
1 4
1 5
Output
6
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define int ll
using VI = vector<int>;
using VVI = vector<VI>;
using PII = pair<int, int>;
#define FOR(i, a, n) for (ll i = (ll)a; i < (ll)n; ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(x) x.begin(), x.end()
#define PB push_back
const ll LLINF = (1LL<<60);
const int INF = (1LL<<30);
const int MOD = 1000000007;
template <typename T> T &chmin(T &a, const T &b) { return a = min(a, b); }
template <typename T> T &chmax(T &a, const T &b) { return a = max(a, b); }
template <typename T> bool IN(T a, T b, T x) { return a<=x&&x<b; }
template<typename T> T ceil(T a, T b) { return a/b + !!(a%b); }
template<class S,class T>
ostream &operator <<(ostream& out,const pair<S,T>& a){
out<<'('<<a.first<<','<<a.second<<')';
return out;
}
template<class T>
ostream &operator <<(ostream& out,const vector<T>& a){
out<<'[';
REP(i, a.size()) {out<<a[i];if(i!=a.size()-1)out<<',';}
out<<']';
return out;
}
int dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0};
int b = 1007, mo = 1e9+7;
VI g[100010];
map<int,int> v;
// 部分木xのハッシュを返す
int func(int x, int p) {
int ret = b;
for(int e: g[x]) {
if(e == p) continue;
(ret += func(e, x) * b % mo) %= mo;
}
v[ret]++;
return ret;
}
signed main(void)
{
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
REP(i, n-1) {
int a, b;
cin >> a >> b; a--, b--;
g[a].PB(b);
g[b].PB(a);
}
mo = 1e9+7;
b = rand() % mo;
v.clear();
func(0, -1);
int ret = 0;
for(auto i: v) ret += i.second*(i.second-1)/2;
cout << ret << endl;
return 0;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
Dima, Inna and Seryozha have gathered in a room. That's right, someone's got to go. To cheer Seryozha up and inspire him to have a walk, Inna decided to cook something.
Dima and Seryozha have n fruits in the fridge. Each fruit has two parameters: the taste and the number of calories. Inna decided to make a fruit salad, so she wants to take some fruits from the fridge for it. Inna follows a certain principle as she chooses the fruits: the total taste to the total calories ratio of the chosen fruits must equal k. In other words, <image> , where aj is the taste of the j-th chosen fruit and bj is its calories.
Inna hasn't chosen the fruits yet, she is thinking: what is the maximum taste of the chosen fruits if she strictly follows her principle? Help Inna solve this culinary problem — now the happiness of a young couple is in your hands!
Inna loves Dima very much so she wants to make the salad from at least one fruit.
Input
The first line of the input contains two integers n, k (1 ≤ n ≤ 100, 1 ≤ k ≤ 10). The second line of the input contains n integers a1, a2, ..., an (1 ≤ ai ≤ 100) — the fruits' tastes. The third line of the input contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 100) — the fruits' calories. Fruit number i has taste ai and calories bi.
Output
If there is no way Inna can choose the fruits for the salad, print in the single line number -1. Otherwise, print a single integer — the maximum possible sum of the taste values of the chosen fruits.
Examples
Input
3 2
10 8 1
2 7 1
Output
18
Input
5 3
4 4 4 4 4
2 2 2 2 2
Output
-1
Note
In the first test sample we can get the total taste of the fruits equal to 18 if we choose fruit number 1 and fruit number 2, then the total calories will equal 9. The condition <image> fulfills, that's exactly what Inna wants.
In the second test sample we cannot choose the fruits so as to follow Inna's principle.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int a[110], b[110], n, k;
int mem[110][2 * 110 * 100 * 10];
const int med = 100000;
int dfs(int rec, int sum) {
if (mem[rec][sum] != -1) return mem[rec][sum];
if (rec >= n) {
if (sum == med)
return 0;
else
return -1 << 29;
}
return mem[rec][sum] = max(dfs(rec + 1, sum),
dfs(rec + 1, sum - a[rec] + k * b[rec]) + a[rec]);
}
int main() {
memset(mem, -1, sizeof(mem));
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
cin >> b[i];
}
dfs(0, med);
for (int i = n; i >= 0; i--) {
for (int j = -40; j <= 40; j++) {
}
}
if (mem[0][med] > 0)
cout << mem[0][med] << endl;
else
cout << -1 << endl;
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
You are given an array a_1, a_2, ... , a_n consisting of integers from 0 to 9. A subarray a_l, a_{l+1}, a_{l+2}, ... , a_{r-1}, a_r is good if the sum of elements of this subarray is equal to the length of this subarray (∑_{i=l}^{r} a_i = r - l + 1).
For example, if a = [1, 2, 0], then there are 3 good subarrays: a_{1 ... 1} = [1], a_{2 ... 3} = [2, 0] and a_{1 ... 3} = [1, 2, 0].
Calculate the number of good subarrays of the array a.
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains one integer n (1 ≤ n ≤ 10^5) — the length of the array a.
The second line of each test case contains a string consisting of n decimal digits, where the i-th digit is equal to the value of a_i.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case print one integer — the number of good subarrays of the array a.
Example
Input
3
3
120
5
11011
6
600005
Output
3
6
1
Note
The first test case is considered in the statement.
In the second test case, there are 6 good subarrays: a_{1 ... 1}, a_{2 ... 2}, a_{1 ... 2}, a_{4 ... 4}, a_{5 ... 5} and a_{4 ... 5}.
In the third test case there is only one good subarray: a_{2 ... 6}.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long int inf = 2e9;
const long long MOD = 998244353;
const int MAX = 2e8 + 1;
const long long int N = 1000000;
using namespace std;
void solve() {
int n;
string s;
cin >> n >> s;
long long ans = 0, prefixSum = 0;
map<int, int> map;
map[prefixSum]++;
for (int i = 0; i < n; ++i) {
prefixSum += s[i] - '0';
ans += map[prefixSum - i - 1];
map[prefixSum - i - 1]++;
}
cout << ans << endl;
}
int main() {
int tc;
cin >> tc;
while (tc--) solve();
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
You are given an integer n (n ≥ 0) represented with k digits in base (radix) b. So,
$$$n = a_1 ⋅ b^{k-1} + a_2 ⋅ b^{k-2} + … a_{k-1} ⋅ b + a_k.$$$
For example, if b=17, k=3 and a=[11, 15, 7] then n=11⋅17^2+15⋅17+7=3179+255+7=3441.
Determine whether n is even or odd.
Input
The first line contains two integers b and k (2≤ b≤ 100, 1≤ k≤ 10^5) — the base of the number and the number of digits.
The second line contains k integers a_1, a_2, …, a_k (0≤ a_i < b) — the digits of n.
The representation of n contains no unnecessary leading zero. That is, a_1 can be equal to 0 only if k = 1.
Output
Print "even" if n is even, otherwise print "odd".
You can print each letter in any case (upper or lower).
Examples
Input
13 3
3 2 7
Output
even
Input
10 9
1 2 3 4 5 6 7 8 9
Output
odd
Input
99 5
32 92 85 74 4
Output
odd
Input
2 2
1 0
Output
even
Note
In the first example, n = 3 ⋅ 13^2 + 2 ⋅ 13 + 7 = 540, which is even.
In the second example, n = 123456789 is odd.
In the third example, n = 32 ⋅ 99^4 + 92 ⋅ 99^3 + 85 ⋅ 99^2 + 74 ⋅ 99 + 4 = 3164015155 is odd.
In the fourth example n = 2.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int b, n, k, r;
int a[100005];
int main() {
cin >> b >> n;
if (b % 2 == 0)
k = 0;
else
k = 1;
r = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (i == n) {
if (a[i] % 2 != 0) r++;
} else if ((a[i] % 2 == 1) && (k == 1))
r++;
}
if (r % 2 == 0)
cout << "even";
else
cout << "odd";
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
Recently a new building with a new layout was constructed in Monocarp's hometown. According to this new layout, the building consists of three types of apartments: three-room, five-room, and seven-room apartments. It's also known that each room of each apartment has exactly one window. In other words, a three-room apartment has three windows, a five-room — five windows, and a seven-room — seven windows.
Monocarp went around the building and counted n windows. Now he is wondering, how many apartments of each type the building may have.
Unfortunately, Monocarp only recently has learned to count, so he is asking you to help him to calculate the possible quantities of three-room, five-room, and seven-room apartments in the building that has n windows. If there are multiple answers, you can print any of them.
Here are some examples:
* if Monocarp has counted 30 windows, there could have been 2 three-room apartments, 2 five-room apartments and 2 seven-room apartments, since 2 ⋅ 3 + 2 ⋅ 5 + 2 ⋅ 7 = 30;
* if Monocarp has counted 67 windows, there could have been 7 three-room apartments, 5 five-room apartments and 3 seven-room apartments, since 7 ⋅ 3 + 5 ⋅ 5 + 3 ⋅ 7 = 67;
* if Monocarp has counted 4 windows, he should have mistaken since no building with the aforementioned layout can have 4 windows.
Input
Th first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases.
The only line of each test case contains one integer n (1 ≤ n ≤ 1000) — the number of windows in the building.
Output
For each test case, if a building with the new layout and the given number of windows just can't exist, print -1.
Otherwise, print three non-negative integers — the possible number of three-room, five-room, and seven-room apartments. If there are multiple answers, print any of them.
Example
Input
4
30
67
4
14
Output
2 2 2
7 5 3
-1
0 0 2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
t = 1;
cin >> t;
while (t-- > 0) {
long long int n;
cin >> n;
if (n == 1 || n == 2 || n == 4) {
cout << "-1";
cout << "\n";
continue;
}
if (!(n % 3))
cout << n / 3 << " "
<< "0"
<< " "
<< "0";
if (n % 3 == 1)
cout << (n - 7) / 3 << " "
<< "0"
<< " "
<< "1";
if (n % 3 == 2)
cout << (n - 5) / 3 << " "
<< "1"
<< " "
<< "0";
cout << "\n";
}
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
Consider the following problem: given an array a containing n integers (indexed from 0 to n-1), find max_{0 ≤ l ≤ r ≤ n-1} ∑_{l ≤ i ≤ r} (r-l+1) ⋅ a_i. In this problem, 1 ≤ n ≤ 2 000 and |a_i| ≤ 10^6.
In an attempt to solve the problem described, Alice quickly came up with a blazing-fast greedy algorithm and coded it. Her implementation in pseudocode is as follows:
function find_answer(n, a)
# Assumes n is an integer between 1 and 2000, inclusive
# Assumes a is a list containing n integers: a[0], a[1], ..., a[n-1]
res = 0
cur = 0
k = -1
for i = 0 to i = n-1
cur = cur + a[i]
if cur < 0
cur = 0
k = i
res = max(res, (i-k)*cur)
return res
Also, as you can see, Alice's idea is not entirely correct. For example, suppose n = 4 and a = [6, -8, 7, -42]. Then, find_answer(n, a) would return 7, but the correct answer is 3 ⋅ (6-8+7) = 15.
You told Alice that her solution is incorrect, but she did not believe what you said.
Given an integer k, you are to find any sequence a of n integers such that the correct answer and the answer produced by Alice's algorithm differ by exactly k. Note that although the choice of n and the content of the sequence is yours, you must still follow the constraints earlier given: that 1 ≤ n ≤ 2 000 and that the absolute value of each element does not exceed 10^6. If there is no such sequence, determine so.
Input
The first and only line contains one integer k (1 ≤ k ≤ 10^9).
Output
If there is no sought sequence, print "-1".
Otherwise, in the first line, print one integer n (1 ≤ n ≤ 2 000), denoting the number of elements in the sequence.
Then, in the second line, print n space-separated integers: a_0, a_1, …, a_{n-1} (|a_i| ≤ 10^6).
Examples
Input
8
Output
4
6 -8 7 -42
Input
612
Output
7
30 -12 -99 123 -2 245 -300
Note
The first sample corresponds to the example given in the problem statement.
In the second sample, one answer is n = 7 with a = [30, -12, -99, 123, -2, 245, -300], in which case find_answer(n, a) returns 1098, while the correct answer is 1710.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long k, l = 2000;
cin >> k;
if (k > 2000 * 1000000) {
cout << -1 << '\n';
return;
}
cout << "2000\n";
long long sum = k + 2000;
cout << "-1 ";
for (int i = 1; i <= 1999; i++) {
if (sum > 1000000) {
cout << "1000000"
<< " \n"[i == 2000];
sum -= 1000000;
} else {
cout << sum << " \n"[i == 2000];
sum = 0;
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
Takahashi has decided to hold fastest-finger-fast quiz games. Kizahashi, who is in charge of making the scoreboard, is struggling to write the program that manages the players' scores in a game, which proceeds as follows.
A game is played by N players, numbered 1 to N. At the beginning of a game, each player has K points.
When a player correctly answers a question, each of the other N-1 players receives minus one (-1) point. There is no other factor that affects the players' scores.
At the end of a game, the players with 0 points or lower are eliminated, and the remaining players survive.
In the last game, the players gave a total of Q correct answers, the i-th of which was given by Player A_i. For Kizahashi, write a program that determines whether each of the N players survived this game.
Constraints
* All values in input are integers.
* 2 \leq N \leq 10^5
* 1 \leq K \leq 10^9
* 1 \leq Q \leq 10^5
* 1 \leq A_i \leq N\ (1 \leq i \leq Q)
Input
Input is given from Standard Input in the following format:
N K Q
A_1
A_2
.
.
.
A_Q
Output
Print N lines. The i-th line should contain `Yes` if Player i survived the game, and `No` otherwise.
Examples
Input
6 3 4
3
1
3
2
Output
No
No
Yes
No
No
No
Input
6 5 4
3
1
3
2
Output
Yes
Yes
Yes
Yes
Yes
Yes
Input
10 13 15
3
1
4
1
5
9
2
6
5
3
5
8
9
7
9
Output
No
No
No
No
Yes
No
No
No
Yes
No
### Response
```cpp
#include<iostream>
using namespace std;
int main(){
int N,K,Q,An,A[100000]={0};
cin>>N>>K>>Q;
for(int i=0;i<Q;i++){
cin>>An;
A[An-1]++;
}
for(int i=0;i<N;i++){
if(A[i]-Q+K<=0)cout<<"No"<<endl;
else cout<<"Yes"<<endl;
}
return 0;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
You will be given a contest schedule for D days. For each d=1,2,\ldots,D, calculate the satisfaction at the end of day d.
Input
Input is given from Standard Input in the form of the input of Problem A followed by the output of Problem A.
D
c_1 c_2 \cdots c_{26}
s_{1,1} s_{1,2} \cdots s_{1,26}
\vdots
s_{D,1} s_{D,2} \cdots s_{D,26}
t_1
t_2
\vdots
t_D
* The constraints and generation methods for the input part are the same as those for Problem A.
* For each d, t_d is an integer satisfying 1\leq t_d \leq 26, and your program is expected to work correctly for any value that meets the constraints.
Output
Let v_d be the satisfaction at the end of day d. Print D integers v_d to Standard Output in the following format:
v_1
v_2
\vdots
v_D
Output
Let v_d be the satisfaction at the end of day d. Print D integers v_d to Standard Output in the following format:
v_1
v_2
\vdots
v_D
Example
Input
5
86 90 69 51 2 96 71 47 88 34 45 46 89 34 31 38 97 84 41 80 14 4 50 83 7 82
19771 12979 18912 10432 10544 12928 13403 3047 10527 9740 8100 92 2856 14730 1396 15905 6534 4650 11469 3628 8433 2994 10899 16396 18355 11424
6674 17707 13855 16407 12232 2886 11908 1705 5000 1537 10440 10711 4917 10770 17272 15364 19277 18094 3929 3705 7169 6159 18683 15410 9092 4570
6878 4239 19925 1799 375 9563 3445 5658 19857 11401 6997 6498 19933 3848 2426 2146 19745 16880 17773 18359 3921 14172 16730 11157 5439 256
8633 15862 15303 10749 18499 7792 10317 5901 9395 11433 3514 3959 5202 19850 19469 9790 5653 784 18500 10552 17975 16615 7852 197 8471 7452
19855 17918 7990 10572 4333 438 9140 9104 12622 4985 12319 4028 19922 12132 16259 17476 2976 547 19195 19830 16285 4806 4471 9457 2864 2192
1
17
13
14
13
Output
18398
35037
51140
65837
79325
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int D,N,x;
N=0;
x=0;
cin >> D;
vector<int> c(26);
vector<int> last(26);
for (int i=0;i<26;i++) {
cin >> c.at(i);
}
vector<vector<int>> s(D,vector<int>(26));
for (int i=0;i<D;i++) {
for (int j=0;j<26;j++) {
cin >> s.at(i).at(j);
}
}
vector<int> t(D);
for (int i=0;i<D;i++) {
cin >> t.at(i);
}
for (int i=0;i<D;i++) {
N=t.at(i)-1;
x+=s.at(i).at(N);
last.at(N)=i+1;
for (int j=0;j<26;j++) {
x-=c.at(j)*(i+1-last.at(j));
}
cout << x << endl;
}
}
``` |
### Prompt
Generate a CPP solution to the following problem:
You have a long fence which consists of n sections. Unfortunately, it is not painted, so you decided to hire q painters to paint it. i-th painter will paint all sections x such that l_i ≤ x ≤ r_i.
Unfortunately, you are on a tight budget, so you may hire only q - 2 painters. Obviously, only painters you hire will do their work.
You want to maximize the number of painted sections if you choose q - 2 painters optimally. A section is considered painted if at least one painter paints it.
Input
The first line contains two integers n and q (3 ≤ n, q ≤ 5000) — the number of sections and the number of painters availible for hire, respectively.
Then q lines follow, each describing one of the painters: i-th line contains two integers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n).
Output
Print one integer — maximum number of painted sections if you hire q - 2 painters.
Examples
Input
7 5
1 4
4 5
5 6
6 7
3 5
Output
7
Input
4 3
1 1
2 2
3 4
Output
2
Input
4 4
1 1
2 2
2 3
3 4
Output
3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n, q, i, j, l, r;
cin >> n >> q;
int auxi[n + 2], sum[n + 2];
memset(auxi, 0, sizeof(auxi));
memset(sum, 0, sizeof(sum));
vector<pair<int, int> > v;
for (i = 0; i < q; i++) {
cin >> l >> r;
v.push_back({l, r});
auxi[r + 1] -= 1;
auxi[l] += 1;
}
int net = 0;
for (i = 0; i <= n + 1; i++) {
net += auxi[i];
sum[i] += net;
}
int ans = 0;
for (i = 0; i < q; i++) {
for (j = 0; j <= n; j++) {
auxi[j] = sum[j];
}
int count = 0;
for (j = v[i].first; j <= v[i].second; j++) {
auxi[j]--;
}
int prefix[n + 1];
prefix[0] = 0;
for (j = 1; j <= n; j++) {
prefix[j] = prefix[j - 1] + (auxi[j] == 1);
if (auxi[j]) count++;
}
for (j = i + 1; j < q; j++) {
ans = max(ans, count - prefix[v[j].second] + prefix[v[j].first - 1]);
}
}
cout << ans << "\n";
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
Vasya had a strictly increasing sequence of positive integers a1, ..., an. Vasya used it to build a new sequence b1, ..., bn, where bi is the sum of digits of ai's decimal representation. Then sequence ai got lost and all that remained is sequence bi.
Vasya wonders what the numbers ai could be like. Of all the possible options he likes the one sequence with the minimum possible last number an. Help Vasya restore the initial sequence.
It is guaranteed that such a sequence always exists.
Input
The first line contains a single integer number n (1 ≤ n ≤ 300).
Next n lines contain integer numbers b1, ..., bn — the required sums of digits. All bi belong to the range 1 ≤ bi ≤ 300.
Output
Print n integer numbers, one per line — the correct option for numbers ai, in order of following in sequence. The sequence should be strictly increasing. The sum of digits of the i-th number should be equal to bi.
If there are multiple sequences with least possible number an, print any of them. Print the numbers without leading zeroes.
Examples
Input
3
1
2
3
Output
1
2
3
Input
3
3
2
1
Output
3
11
100
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n;
int b[3100];
int a[3100];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &b[i]);
int bb = b[i] - b[i - 1], l;
if (bb > 0) {
orzprwang:
l = 1;
while (bb) {
while (a[l] == 9) l++;
a[l]++;
--bb;
}
} else if (bb < 0) {
while (bb) {
if (bb > 0) goto orzprwang;
l = 0;
while (a[++l] == 0)
;
do {
bb += a[l] - 1;
a[l] = 0;
++a[++l];
} while (a[l] >= 10);
}
} else {
l = 0;
while (a[++l] == 0)
;
do {
bb += a[l] - 1;
a[l] = 0;
++a[++l];
} while (a[l] >= 10);
goto orzprwang;
}
int len = 3010;
while (a[len] == 0) --len;
for (int j = len; j >= 1; --j) printf("%d", a[j]);
printf("\n");
}
return 0;
}
``` |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.