text
stringlengths 424
69.5k
|
|---|
### Prompt
Create a solution in Cpp for the following problem:
Let's call a list of positive integers a_0, a_1, ..., a_{n-1} a power sequence if there is a positive integer c, so that for every 0 β€ i β€ n-1 then a_i = c^i.
Given a list of n positive integers a_0, a_1, ..., a_{n-1}, you are allowed to:
* Reorder the list (i.e. pick a permutation p of \{0,1,...,n - 1\} and change a_i to a_{p_i}), then
* Do the following operation any number of times: pick an index i and change a_i to a_i - 1 or a_i + 1 (i.e. increment or decrement a_i by 1) with a cost of 1.
Find the minimum cost to transform a_0, a_1, ..., a_{n-1} into a power sequence.
Input
The first line contains an integer n (3 β€ n β€ 10^5).
The second line contains n integers a_0, a_1, ..., a_{n-1} (1 β€ a_i β€ 10^9).
Output
Print the minimum cost to transform a_0, a_1, ..., a_{n-1} into a power sequence.
Examples
Input
3
1 3 2
Output
1
Input
3
1000000000 1000000000 1000000000
Output
1999982505
Note
In the first example, we first reorder \{1, 3, 2\} into \{1, 2, 3\}, then increment a_2 to 4 with cost 1 to get a power sequence \{1, 2, 4\}.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
const int N = 3e5, M = N;
mt19937_64 rang(
chrono::high_resolution_clock::now().time_since_epoch().count());
int mpow(int base, int exp);
void ipgraph(int n, int m);
void dfs(int u, int par);
vector<int> g[N];
void solve() {
int n;
cin >> n;
vector<long long> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a.begin(), a.end());
long long big = (long long)1e15;
long long ans = big;
long long c = 1;
int k = 0;
while (1) {
long long val = 0, pw = 1;
for (int i = 0; i < n; i++, pw *= c) {
if (pw >= (long long)(big)) {
val = -1;
break;
}
val += abs(pw - a[i]);
}
if (val == -1) break;
ans = min(ans, val);
c++;
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
srand(chrono::high_resolution_clock::now().time_since_epoch().count());
clock_t z = clock();
int t = 1;
while (t--) {
solve();
}
fprintf(stderr, "Total Time: %.3f\n", (double)(clock() - z) / CLOCKS_PER_SEC),
fflush(stderr);
return 0;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
In some country live wizards. They love to ride trolleybuses.
A city in this country has a trolleybus depot with n trolleybuses. Every day the trolleybuses leave the depot, one by one and go to the final station. The final station is at a distance of d meters from the depot. We know for the i-th trolleybus that it leaves at the moment of time ti seconds, can go at a speed of no greater than vi meters per second, and accelerate with an acceleration no greater than a meters per second squared. A trolleybus can decelerate as quickly as you want (magic!). It can change its acceleration as fast as you want, as well. Note that the maximum acceleration is the same for all trolleys.
Despite the magic the trolleys are still powered by an electric circuit and cannot overtake each other (the wires are to blame, of course). If a trolleybus catches up with another one, they go together one right after the other until they arrive at the final station. Also, the drivers are driving so as to arrive at the final station as quickly as possible.
You, as head of the trolleybuses' fans' club, are to determine for each trolley the minimum time by which it can reach the final station. At the time of arrival at the destination station the trolleybus does not necessarily have zero speed. When a trolley is leaving the depot, its speed is considered equal to zero. From the point of view of physics, the trolleybuses can be considered as material points, and also we should ignore the impact on the speed of a trolley bus by everything, except for the acceleration and deceleration provided by the engine.
Input
The first input line contains three space-separated integers n, a, d (1 β€ n β€ 105, 1 β€ a, d β€ 106) β the number of trolleybuses, their maximum acceleration and the distance from the depot to the final station, correspondingly.
Next n lines contain pairs of integers ti vi (0 β€ t1 < t2... < tn - 1 < tn β€ 106, 1 β€ vi β€ 106) β the time when the i-th trolleybus leaves the depot and its maximum speed, correspondingly. The numbers in the lines are separated by spaces.
Output
For each trolleybus print a single line the time it arrives to the final station. Print the times for the trolleybuses in the order in which the trolleybuses are given in the input. The answer will be accepted if the absolute or relative error doesn't exceed 10 - 4.
Examples
Input
3 10 10000
0 10
5 11
1000 1
Output
1000.5000000000
1000.5000000000
11000.0500000000
Input
1 2 26
28 29
Output
33.0990195136
Note
In the first sample the second trolleybus will catch up with the first one, that will happen at distance 510.5 meters from the depot. The trolleybuses will go the remaining 9489.5 meters together at speed 10 meters per second. As a result, both trolleybuses will arrive to the final station by the moment of time 1000.5 seconds. The third trolleybus will not catch up with them. It will arrive to the final station by the moment of time 11000.05 seconds.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000000;
int n;
double a, d;
double v[MAXN], t[MAXN];
double arive[MAXN];
int main() {
cin.sync_with_stdio(false);
cin >> n >> a >> d;
for (int i = 0; i < n; ++i) cin >> t[i] >> v[i];
cout.precision(10);
for (int i = 0; i < n; ++i) {
double r = v[i] / a, d1 = a * r * r / 2;
double res;
if (d1 >= d) {
res = sqrt(2 * d / a) + t[i];
} else {
res = r + (d - d1) / v[i] + t[i];
}
if (i > 0 && arive[i - 1] > res) res = arive[i - 1];
arive[i] = res;
cout << res << endl;
}
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
Little Vasya had n boxes with balls in the room. The boxes stood in a row and were numbered with numbers from 1 to n from left to right.
Once Vasya chose one of the boxes, let's assume that its number is i, took all balls out from it (it is guaranteed that this box originally had at least one ball), and began putting balls (one at a time) to the boxes with numbers i + 1, i + 2, i + 3 and so on. If Vasya puts a ball into the box number n, then the next ball goes to box 1, the next one goes to box 2 and so on. He did it until he had no balls left in his hands. It is possible that Vasya puts multiple balls to the same box, and it is also possible that one or more balls will go to the box number i. If i = n, Vasya puts the first ball into the box number 1, then the next ball goes to box 2 and so on.
For example, let's suppose that initially Vasya had four boxes, and the first box had 3 balls, the second one had 2, the third one had 5 and the fourth one had 4 balls. Then, if i = 3, then Vasya will take all five balls out of the third box and put them in the boxes with numbers: 4, 1, 2, 3, 4. After all Vasya's actions the balls will lie in the boxes as follows: in the first box there are 4 balls, 3 in the second one, 1 in the third one and 6 in the fourth one.
At this point Vasya has completely forgotten the original arrangement of the balls in the boxes, but he knows how they are arranged now, and the number x β the number of the box, where he put the last of the taken out balls.
He asks you to help to find the initial arrangement of the balls in the boxes.
Input
The first line of the input contains two integers n and x (2 β€ n β€ 105, 1 β€ x β€ n), that represent the number of the boxes and the index of the box that got the last ball from Vasya, correspondingly. The second line contains n space-separated integers a1, a2, ..., an, where integer ai (0 β€ ai β€ 109, ax β 0) represents the number of balls in the box with index i after Vasya completes all the actions.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
Print n integers, where the i-th one represents the number of balls in the box number i before Vasya starts acting. Separate the numbers in the output by spaces. If there are multiple correct solutions, you are allowed to print any of them.
Examples
Input
4 4
4 3 1 6
Output
3 2 5 4
Input
5 2
3 2 0 2 7
Output
2 1 4 1 6
Input
3 3
2 3 1
Output
1 2 3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long n, x;
long long minn, mid;
long long a[100009];
int main() {
while (cin >> n >> x) {
minn = 1e9 + 9;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
if (minn > a[i]) minn = a[i], mid = i;
}
long long ans = 0;
for (int i = 1; i <= n; ++i) {
a[i] = a[i] - minn;
ans = ans + minn;
}
int ms = mid;
bool flg = false;
for (int i = x; i > 0; --i)
if (a[i] == 0) {
mid = i;
flg = true;
break;
}
if (!flg) {
for (int i = n; i > 0; --i)
if (a[i] == 0) {
mid = i;
flg = true;
break;
}
}
x = x % n + 1;
for (int i = (mid + 1 - 1) % n + 1; i != x; i = (i) % n + 1) {
a[i]--;
ans++;
}
for (int i = 1; i <= n; ++i) {
if (i == mid) a[i] = ans;
if (i != n)
cout << a[i] << " ";
else
cout << a[i] << endl;
}
}
return 0;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
Miyako came to the flea kingdom with a ukulele. She became good friends with local flea residents and played beautiful music for them every day.
In return, the fleas made a bigger ukulele for her: it has n strings, and each string has (10^{18} + 1) frets numerated from 0 to 10^{18}. The fleas use the array s_1, s_2, β¦, s_n to describe the ukulele's tuning, that is, the pitch of the j-th fret on the i-th string is the integer s_i + j.
Miyako is about to leave the kingdom, but the fleas hope that Miyako will answer some last questions for them.
Each question is in the form of: "How many different pitches are there, if we consider frets between l and r (inclusive) on all strings?"
Miyako is about to visit the cricket kingdom and has no time to answer all the questions. Please help her with this task!
Formally, you are given a matrix with n rows and (10^{18}+1) columns, where the cell in the i-th row and j-th column (0 β€ j β€ 10^{18}) contains the integer s_i + j. You are to answer q queries, in the k-th query you have to answer the number of distinct integers in the matrix from the l_k-th to the r_k-th columns, inclusive.
Input
The first line contains an integer n (1 β€ n β€ 100 000) β the number of strings.
The second line contains n integers s_1, s_2, β¦, s_n (0 β€ s_i β€ 10^{18}) β the tuning of the ukulele.
The third line contains an integer q (1 β€ q β€ 100 000) β the number of questions.
The k-th among the following q lines contains two integers l_kοΌr_k (0 β€ l_k β€ r_k β€ 10^{18}) β a question from the fleas.
Output
Output one number for each question, separated by spaces β the number of different pitches.
Examples
Input
6
3 1 4 1 5 9
3
7 7
0 2
8 17
Output
5 10 18
Input
2
1 500000000000000000
2
1000000000000000000 1000000000000000000
0 1000000000000000000
Output
2 1500000000000000000
Note
For the first example, the pitches on the 6 strings are as follows.
$$$ \begin{matrix} Fret & 0 & 1 & 2 & 3 & 4 & 5 & 6 & 7 & β¦ \\\ s_1: & 3 & 4 & 5 & 6 & 7 & 8 & 9 & 10 & ... \\\ s_2: & 1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 & ... \\\ s_3: & 4 & 5 & 6 & 7 & 8 & 9 & 10 & 11 & ... \\\ s_4: & 1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 & ... \\\ s_5: & 5 & 6 & 7 & 8 & 9 & 10 & 11 & 12 & ... \\\ s_6: & 9 & 10 & 11 & 12 & 13 & 14 & 15 & 16 & ... \end{matrix} $$$
There are 5 different pitches on fret 7 β 8, 10, 11, 12, 16.
There are 10 different pitches on frets 0, 1, 2 β 1, 2, 3, 4, 5, 6, 7, 9, 10, 11.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long fun(vector<long long> &v, long long w) {
long long l = 0, r = (long long)v.size() - 1;
long long ans = -1;
while (l <= r) {
long long mid = (l + r) / 2;
if (v[mid] <= w) {
ans = mid;
l = mid + 1;
} else {
r = mid - 1;
}
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(nullptr);
long long n;
cin >> n;
vector<long long> v(n);
for (long long &i : v) {
cin >> i;
}
sort(v.begin(), v.end());
vector<long long> t(n);
for (long long i = 1; i < n; i++) {
t[i] = v[i] - v[i - 1];
}
sort(t.begin(), t.end());
vector<long long> cu(n);
for (long long i = 1; i < n; i++) {
cu[i] = t[i] + cu[i - 1];
}
long long q;
cin >> q;
while (q--) {
long long ans = 0;
long long l, r;
cin >> l >> r;
long long w = r - l + 1;
ans += w;
long long in = fun(t, w);
ans += cu[in];
ans += w * ((long long)t.size() - in - 1);
cout << ans << " ";
}
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
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;
const int maxn = 1010;
const int INF = 0x3f3f3f3f;
int n, m, sum = 0, sx, sy, ex, ey, cnt = 0, lstep;
char mp[maxn][maxn];
int vis[maxn][maxn], en[maxn][maxn], nu[maxn * maxn][2];
int dir[4][2] = {{0, 1}, {0, -1}, {-1, 0}, {1, 0}};
struct node {
int x, y, step;
};
void BFS() {
memset(vis, 0, sizeof(vis));
queue<node> q;
q.push((node){ex, ey, 0});
while (q.size()) {
node it = q.front();
q.pop();
if (it.x == sx && it.y == sy) {
lstep = it.step;
return;
}
for (int i = 0; i < 4; i++) {
int tx = it.x + dir[i][0];
int ty = it.y + dir[i][1];
if (tx < 1 || tx > n || ty < 1 || ty > m) continue;
if (!vis[tx][ty] && mp[tx][ty] != 'T') {
if (mp[tx][ty] > '0' && mp[tx][ty] <= '9') {
en[tx][ty] = it.step + 1;
}
vis[tx][ty] = 1;
q.push((node){tx, ty, it.step + 1});
}
}
}
}
int main() {
memset(en, 0x3f, sizeof(en));
scanf("%d%d", &n, &m);
getchar();
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
mp[i][j] = getchar();
if (mp[i][j] == 'S') {
sx = i;
sy = j;
} else if (mp[i][j] == 'E') {
ex = i;
ey = j;
} else if (mp[i][j] > '0' && mp[i][j] <= '9') {
nu[++cnt][0] = i;
nu[cnt][1] = j;
}
}
getchar();
}
BFS();
for (int i = 1; i <= cnt; i++) {
if (en[nu[i][0]][nu[i][1]] <= lstep) sum += (mp[nu[i][0]][nu[i][1]] - '0');
}
printf("%d\n", sum);
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
Let J(n) be a three-dimensional body that
* is a union of unit cubes whose all vertices lie on integer coordinates,
* contains all points that are closer than the distance of βn to the origin, and
* is the smallest of all such bodies.
The figure below shows how J(1), J(2), and J(3) look.
<image>
Figure 1: Jaggie Spheres for n = 1, 2, 3
Your task is to calculate how many faces J(n) have. Here, we define two square belong to the same face if they are parallel and share an edge, but donβt if they share just a vertex.
Input
The input consists of multiple data sets, each of which comes with a single line containing an integer n (1 β€ n β€ 1000000). The end of input is indicated by n = 0.
Output
For each data set, print the number of faces J(n) have.
Example
Input
1
2
3
4
0
Output
6
30
30
6
### Response
```cpp
#include<iostream>
#include<map>
#include<cmath>
#include<algorithm>
using namespace std;
#define REP(i,b,n) for(int i=b;i<n;i++)
#define rep(i,n) REP(i,0,n)
const int N = 1001;
int compute(int x,int y,int n){
double z = sqrt(n-(double)x*x-(double)y*y);
if (isnan(z))return 0;
if ( fabs(z-(n-(double)x*x-(double)y*y))<1e-10)return (int)z;
else return (int)ceil(z);
}
int height[N][N];
int th[N+1][N+1];
void estimate(int n,int tn){
rep(i,tn)rep(j,tn)height[i][j]=0;
rep(y,tn+1){
rep(x,tn+1)th[y][x]=compute(x,y,n);
}
rep(y,tn){
rep(x,tn){
int p=0;
height[y][x]=max(max(th[y][x],th[y+1][x]),
max(th[y+1][x],th[y+1][x+1]));
}
}
}
int dx[]={0,0,1,-1};
int dy[]={1,-1,0,0};
void dfs(int n,int y,int x,int d,bool &xzero,bool &yzero){
if (y==-1||x==-1||y==n||x==n||height[y][x] != d)return;
height[y][x]=0;
if(x==0)xzero=true;
if(y==0)yzero=true;
rep(i,4)dfs(n,y+dy[i],x+dx[i],d,xzero,yzero);
}
int solve(int n){
int ret=0;
rep(i,n){
rep(j,n){
if (height[i][j] != 0){
bool xzero=false,yzero=false;
int tmp=1;
dfs(n,i,j,height[i][j],xzero,yzero);
if (xzero&&yzero);
else if (xzero||yzero)tmp*=2;
else tmp*=4;
ret+=tmp;
}
}
}
return ret*6;
}
int main(){
int n;
while(cin>>n && n){
int tn = (int)(ceil(sqrt(n)));
estimate(n,tn);
cout << solve(tn) << endl;
}
return false;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1β€iβ€n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1β€iβ€n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 β€ n β€ 10^5
* |a_i| β€ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8
### Response
```cpp
#include <iostream>
#include <algorithm>
#include <string>
#include <vector>
typedef long long ll;
using namespace std;
ll n, a, s1, s2, c1, c2;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a;
s1 += a;
s2 += a;
if (i % 2) {
if (s1 <= 0) c1 += 1 - s1, s1 = 1;
if (s2 >= 0) c2 += 1 + s2, s2 = -1;
}
else {
if (s1 >= 0) c1 += 1 + s1, s1 = -1;
if (s2 <= 0) c2 += 1 - s2, s2 = 1;
}
}
cout << min(c1, c2) << endl;
return 0;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
The country has n cities and n - 1 bidirectional roads, it is possible to get from every city to any other one if you move only along the roads. The cities are numbered with integers from 1 to n inclusive.
All the roads are initially bad, but the government wants to improve the state of some roads. We will assume that the citizens are happy about road improvement if the path from the capital located in city x to any other city contains at most one bad road.
Your task is β for every possible x determine the number of ways of improving the quality of some roads in order to meet the citizens' condition. As those values can be rather large, you need to print each value modulo 1 000 000 007 (109 + 7).
Input
The first line of the input contains a single integer n (2 β€ n β€ 2Β·105) β the number of cities in the country. Next line contains n - 1 positive integers p2, p3, p4, ..., pn (1 β€ pi β€ i - 1) β the description of the roads in the country. Number pi means that the country has a road connecting city pi and city i.
Output
Print n integers a1, a2, ..., an, where ai is the sought number of ways to improve the quality of the roads modulo 1 000 000 007 (109 + 7), if the capital of the country is at city number i.
Examples
Input
3
1 1
Output
4 3 3
Input
5
1 2 3 4
Output
5 8 9 8 5
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2e5 + 9;
const long long MOD = 1e9 + 7;
long long dp[MAX], dp2[MAX];
vector<int> g[MAX];
void dfs1(int v) {
dp[v] = 1;
for (auto u : g[v]) {
dfs1(u);
dp[v] = dp[v] * (dp[u] + 1) % MOD;
}
return;
}
void dfs2(int v) {
long long p1[g[v].size()];
long long p2[g[v].size()];
for (int i = 0; i < g[v].size(); i++) {
int u = g[v][i];
p1[i] = ((i == 0) ? (dp[u] + 1) : p1[i - 1] * (dp[u] + 1) % MOD);
}
for (int i = g[v].size() - 1; i >= 0; i--) {
int u = g[v][i];
p2[i] =
((i == g[v].size() - 1) ? (dp[u] + 1) : p2[i + 1] * (dp[u] + 1) % MOD);
}
for (int i = 0; i < g[v].size(); i++) {
int u = g[v][i];
long long m = ((i == g[v].size() - 1) ? 1 : p2[i + 1]) *
((i == 0) ? 1 : p1[i - 1]) % MOD;
m = m * dp2[v] % MOD;
dp2[u] = m + 1;
dfs2(u);
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n - 1; i++) {
int p;
cin >> p;
p--;
g[p].push_back(i + 1);
}
dp2[0] = 1;
dfs1(0);
dfs2(0);
for (int i = 0; i < n; i++) {
cout << dp[i] * max(dp2[i], (long long)1) % MOD << " ";
}
cout << "\n";
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
Awruk is taking part in elections in his school. It is the final round. He has only one opponent β Elodreip. The are n students in the school. Each student has exactly k votes and is obligated to use all of them. So Awruk knows that if a person gives a_i votes for Elodreip, than he will get exactly k - a_i votes from this person. Of course 0 β€ k - a_i holds.
Awruk knows that if he loses his life is over. He has been speaking a lot with his friends and now he knows a_1, a_2, ..., a_n β how many votes for Elodreip each student wants to give. Now he wants to change the number k to win the elections. Of course he knows that bigger k means bigger chance that somebody may notice that he has changed something and then he will be disqualified.
So, Awruk knows a_1, a_2, ..., a_n β how many votes each student will give to his opponent. Help him select the smallest winning number k. In order to win, Awruk needs to get strictly more votes than Elodreip.
Input
The first line contains integer n (1 β€ n β€ 100) β the number of students in the school.
The second line contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 100) β the number of votes each student gives to Elodreip.
Output
Output the smallest integer k (k β₯ max a_i) which gives Awruk the victory. In order to win, Awruk needs to get strictly more votes than Elodreip.
Examples
Input
5
1 1 1 5 1
Output
5
Input
5
2 2 3 2 2
Output
5
Note
In the first example, Elodreip gets 1 + 1 + 1 + 5 + 1 = 9 votes. The smallest possible k is 5 (it surely can't be less due to the fourth person), and it leads to 4 + 4 + 4 + 0 + 4 = 16 votes for Awruk, which is enough to win.
In the second example, Elodreip gets 11 votes. If k = 4, Awruk gets 9 votes and loses to Elodreip.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
cin >> n;
double sum = 0;
int a, best = 0;
for (int i = 0; i < n; ++i) cin >> a, sum += 2 * a, best = max(best, a);
if (sum / n == ceil(sum / n))
sum = sum / n + 1;
else
sum = ceil(sum / n);
cout << max(best, int(sum)) << '\n';
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
Life in Bertown has become hard. The city has too many roads and the government spends too much to maintain them. There are n junctions and m two way roads, at which one can get from each junction to any other one. The mayor wants to close some roads so that the number of roads left totaled to n - 1 roads and it were still possible to get from each junction to any other one. Besides, the mayor is concerned with the number of dead ends which are the junctions from which only one road goes. There shouldn't be too many or too few junctions. Having discussed the problem, the mayor and his assistants decided that after the roads are closed, the road map should contain exactly k dead ends. Your task is to count the number of different ways of closing the roads at which the following conditions are met:
* There are exactly n - 1 roads left.
* It is possible to get from each junction to any other one.
* There are exactly k dead ends on the resulting map.
Two ways are considered different if there is a road that is closed in the first way, and is open in the second one.
Input
The first line contains three integers n, m and k (3 β€ n β€ 10, n - 1 β€ m β€ nΒ·(n - 1) / 2, 2 β€ k β€ n - 1) which represent the number of junctions, roads and dead ends correspondingly. Then follow m lines each containing two different integers v1 and v2 (1 β€ v1, v2 β€ n, v1 β v2) which represent the number of junctions connected by another road. There can be no more than one road between every pair of junctions. The junctions are numbered with integers from 1 to n. It is guaranteed that it is possible to get from each junction to any other one along the original roads.
Output
Print a single number β the required number of ways.
Examples
Input
3 3 2
1 2
2 3
1 3
Output
3
Input
4 6 2
1 2
2 3
3 4
4 1
1 3
2 4
Output
12
Input
4 6 3
1 2
2 3
3 4
4 1
1 3
2 4
Output
4
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m, k, dp[1 << ((int)12)][1 << ((int)12)];
bool a[((int)12)][((int)12)];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
for (int i = 0; i < m; i++) {
int v, u;
cin >> v >> u;
v--;
u--;
dp[(1 << v) + (1 << u)][(1 << v) + (1 << u)] = a[v][u] = a[u][v] = 1;
}
for (int i = 0; i < (1 << n); i++)
for (int j = 0; j < (1 << n); j++)
if (dp[i][j]) {
if (__builtin_popcount(i) > 2) dp[i][j] /= __builtin_popcount(j);
for (int p = 0; p < n; p++)
if (!((1 << p) & i))
for (int q = 0; q < n; q++)
if (((1 << q) & i) && a[p][q]) {
if (((1 << q) & j))
dp[(i + (1 << p))][(j - (1 << q) + (1 << p))] += dp[i][j];
else
dp[(i + (1 << p))][(j + (1 << p))] += dp[i][j];
}
}
int ans = 0;
for (int i = 0; i < (1 << n); i++)
if (__builtin_popcount(i) == k) ans += dp[((1 << n) - 1)][i];
cout << ans;
return 0;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
A programming coach has n students to teach. We know that n is divisible by 3. Let's assume that all students are numbered from 1 to n, inclusive.
Before the university programming championship the coach wants to split all students into groups of three. For some pairs of students we know that they want to be on the same team. Besides, if the i-th student wants to be on the same team with the j-th one, then the j-th student wants to be on the same team with the i-th one. The coach wants the teams to show good results, so he wants the following condition to hold: if the i-th student wants to be on the same team with the j-th, then the i-th and the j-th students must be on the same team. Also, it is obvious that each student must be on exactly one team.
Help the coach and divide the teams the way he wants.
Input
The first line of the input contains integers n and m (3 β€ n β€ 48, <image>. Then follow m lines, each contains a pair of integers ai, bi (1 β€ ai < bi β€ n) β the pair ai, bi means that students with numbers ai and bi want to be on the same team.
It is guaranteed that n is divisible by 3. It is guaranteed that each pair ai, bi occurs in the input at most once.
Output
If the required division into teams doesn't exist, print number -1. Otherwise, print <image> lines. In each line print three integers xi, yi, zi (1 β€ xi, yi, zi β€ n) β the i-th team.
If there are multiple answers, you are allowed to print any of them.
Examples
Input
3 0
Output
3 2 1
Input
6 4
1 2
2 3
3 4
5 6
Output
-1
Input
3 3
1 2
2 3
1 3
Output
3 2 1
### Response
```cpp
#include <bits/stdc++.h>
int input() {
int t = 0;
char c;
c = getchar();
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') {
t = (t << 3) + (t << 1) + c - '0';
c = getchar();
}
return t;
}
int main() {
int m, n, i, j, k, x, y, flag = 0, t;
int g[20][4] = {0}, group[100] = {0}, gno = 0;
n = input();
m = input();
for (i = 1; i <= m; i++) {
x = input();
y = input();
if (flag == 1) continue;
if (group[x] != 0 && group[y] != 0) {
if (group[x] == group[y])
;
else
flag = 1;
} else if (group[x] == 0 && group[y] == 0) {
gno++;
g[gno][1] = x;
g[gno][0] = y;
group[x] = gno;
group[y] = gno;
} else if (group[x] != 0 && group[y] == 0) {
t = group[x];
if (g[t][2] == 0) {
g[t][2] = y;
group[y] = t;
} else
flag = 1;
} else if (group[x] == 0 && group[y] != 0) {
t = group[y];
if (g[t][2] == 0) {
g[t][2] = y;
group[y] = t;
} else
flag = 1;
}
}
if (flag == 1 || gno > n / 3) {
printf("-1");
return 0;
}
x = n / 3;
int count = 0;
for (i = 1; i <= n; i++) {
if (group[i] == 0) count++;
}
for (i = 1; i <= n; i++) {
if (group[i] != 0)
;
else {
for (j = 1; j <= x; j++) {
if (g[j][0] == 0) {
g[j][0] = i;
group[i] = j;
break;
} else if (g[j][1] == 0) {
g[j][1] = i;
group[i] = j;
break;
} else if (g[j][2] == 0) {
g[j][2] = i;
group[i] = j;
break;
}
}
}
}
for (i = 1; i <= x; i++) {
printf("%d %d %d\n", g[i][0], g[i][1], g[i][2]);
}
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
In the beginning, Takahashi has A cookies, and Aoki has B cookies. They will perform the following operation alternately, starting from Takahashi:
* If the number of cookies in his hand is odd, eat one of those cookies; if the number is even, do nothing. Then, give one-half of the cookies in his hand to the other person.
Find the numbers of cookies Takahashi and Aoki respectively have after performing K operations in total.
Constraints
* 1 \leq A,B \leq 10^9
* 1 \leq K \leq 100
* A,B and K are integers.
Input
Input is given from Standard Input in the following format:
A B K
Output
Print the number of cookies Takahashi has, and the number of cookies Aoki has, in this order, after performing K operations in total.
Examples
Input
5 4 2
Output
5 3
Input
3 3 3
Output
1 3
Input
314159265 358979323 84
Output
448759046 224379523
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll a, b, k;
int main(){
cin>>a>>b>>k;
for(int i=0;i<k;i++){
if(i%2==0){
if(a%2==1) a--;
b+=a/2; a/=2;
} else {
if(b%2==1) b--;
a+=b/2; b/=2;
}
}
cout<<a<<" "<<b<<endl;
return 0;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
Young wilderness explorers set off to their first expedition led by senior explorer Russell. Explorers went into a forest, set up a camp and decided to split into groups to explore as much interesting locations as possible. Russell was trying to form groups, but ran into some difficulties...
Most of the young explorers are inexperienced, and sending them alone would be a mistake. Even Russell himself became senior explorer not long ago. Each of young explorers has a positive integer parameter e_i β his inexperience. Russell decided that an explorer with inexperience e can only join the group of e or more people.
Now Russell needs to figure out how many groups he can organize. It's not necessary to include every explorer in one of the groups: some can stay in the camp. Russell is worried about this expedition, so he asked you to help him.
Input
The first line contains the number of independent test cases T(1 β€ T β€ 2 β
10^5). Next 2T lines contain description of test cases.
The first line of description of each test case contains the number of young explorers N (1 β€ N β€ 2 β
10^5).
The second line contains N integers e_1, e_2, β¦, e_N (1 β€ e_i β€ N), where e_i is the inexperience of the i-th explorer.
It's guaranteed that sum of all N doesn't exceed 3 β
10^5.
Output
Print T numbers, each number on a separate line.
In i-th line print the maximum number of groups Russell can form in i-th test case.
Example
Input
2
3
1 1 1
5
2 3 1 2 2
Output
3
2
Note
In the first example we can organize three groups. There will be only one explorer in each group. It's correct because inexperience of each explorer equals to 1, so it's not less than the size of his group.
In the second example we can organize two groups. Explorers with inexperience 1, 2 and 3 will form the first group, and the other two explorers with inexperience equal to 2 will form the second group.
This solution is not unique. For example, we can form the first group using the three explorers with inexperience equal to 2, and the second group using only one explorer with inexperience equal to 1. In this case the young explorer with inexperience equal to 3 will not be included in any group.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
map<int, int> m;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int k;
cin >> k;
if (m.find(k) != m.end()) {
m[k]++;
} else {
m.insert(make_pair(k, 1));
}
}
int ans = 0;
for (auto& x : m) {
ans += x.second / x.first;
if (x.second % x.first != 0) {
for (int i = x.first + 1; i <= n; i++) {
if (m.find(i) != m.end()) {
m[i] += (x.second % x.first);
break;
}
}
}
}
cout << ans << endl;
m.clear();
}
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Your company was appointed to lay new asphalt on the highway of length n. You know that every day you can either repair one unit of the highway (lay new asphalt over one unit of the highway) or skip repairing.
Skipping the repair is necessary because of the climate. The climate in your region is periodical: there are g days when the weather is good and if you lay new asphalt these days it becomes high-quality pavement; after that, the weather during the next b days is bad, and if you lay new asphalt these days it becomes low-quality pavement; again g good days, b bad days and so on.
You can be sure that you start repairing at the start of a good season, in other words, days 1, 2, ..., g are good.
You don't really care about the quality of the highway, you just want to make sure that at least half of the highway will have high-quality pavement. For example, if the n = 5 then at least 3 units of the highway should have high quality; if n = 4 then at least 2 units should have high quality.
What is the minimum number of days is needed to finish the repair of the whole highway?
Input
The first line contains a single integer T (1 β€ T β€ 10^4) β the number of test cases.
Next T lines contain test cases β one per line. Each line contains three integers n, g and b (1 β€ n, g, b β€ 10^9) β the length of the highway and the number of good and bad days respectively.
Output
Print T integers β one per test case. For each test case, print the minimum number of days required to repair the whole highway if at least half of it should have high quality.
Example
Input
3
5 1 1
8 10 10
1000000 1 1000000
Output
5
8
499999500000
Note
In the first test case, you can just lay new asphalt each day, since days 1, 3, 5 are good.
In the second test case, you can also lay new asphalt each day, since days 1-8 are good.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin >> t;
while (t--) {
long long int n, g, b;
cin >> n >> g >> b;
long long int m = n;
n = (n + 1) / 2;
long long int ans = (n / g) * (g + b);
if (n % g == 0) {
ans -= b;
} else {
ans += n % g;
}
cout << max(ans, m) << endl;
}
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
Snuke loves working out. He is now exercising N times.
Before he starts exercising, his power is 1. After he exercises for the i-th time, his power gets multiplied by i.
Find Snuke's power after he exercises N times. Since the answer can be extremely large, print the answer modulo 10^{9}+7.
Constraints
* 1 β€ N β€ 10^{5}
Input
The input is given from Standard Input in the following format:
N
Output
Print the answer modulo 10^{9}+7.
Examples
Input
3
Output
6
Input
10
Output
3628800
Input
100000
Output
457992974
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(){
int n;
cin >> n;
long long tmp=1;
for(int i=n;i>0;i--){
tmp*=i;
tmp%=1000000007;
}
cout << tmp << endl;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
problem
The IOI country consists of N towns from town 1 to town N, and the towns are connected by roads. The IOI country has K roads, all of which connect two different towns. Cars can move freely in both directions on the road, but they cannot go from one town to another through anything other than the road.
JOI, who lives in Town 1 of the IOI country, decided to take a taxi to his grandmother's house in Town N. There are N taxi companies in the IOI country, from taxi company 1 to taxi company N. Taxi companies in IOI have the following slightly special rules:
* You can take a taxi from taxi company i only in town i.
* The taxi fare of taxi company i is Ci regardless of the distance used.
* The taxi of taxi company i can only pass up to Ri roads in a row after boarding.
For example, if R1 = 2, if you take a taxi from town 1 to taxi company 1, you can only take up to 2 roads, so you need to change taxis in the middle of the town to go through 3 or more roads. ..
JOI cannot take or get off a taxi outside the town. Also, transportation other than taxis cannot be used. Create a program to find the minimum total fare required for JOI to reach town N.
input
The input consists of 1 + N + K lines.
On the first line, two integers N, K (2 β€ N β€ 5000, N -1 β€ K β€ 10000) are written separated by a blank. This means that the IOI country consists of N towns and the number of roads in the IOI country is K.
On the i-th line (1 β€ i β€ N) of the following N lines, two integers Ci and Ri (1 β€ Ci β€ 10000, 1 β€ Ri β€ N) are written separated by a blank. This means that the taxi fare of taxi company i is Ci, and you can only pass up to Ri roads in a row after boarding.
On the jth line (1 β€ j β€ K) of the following K lines, two different integers Aj and Bj (1 β€ Aj <Bj β€ N) are written separated by a blank. This means that there is a road between town Aj and town Bj. The same (Aj, Bj) pair has never been written more than once.
Given the input data, it is guaranteed that you can take a taxi from any town to any other town.
output
JOI Output an integer on one line that represents the minimum total fare required for you to travel from town 1 to town N.
Examples
Input
6 6
400 2
200 1
600 3
1000 1
300 5
700 4
1 2
2 3
3 6
4 6
1 5
2 4
Output
700
Input
None
Output
None
### Response
```cpp
#include <cstdio>
#include <cstring>
#include <queue>
#include <vector>
using namespace std;
typedef pair<int,int> P;
int cs[11451],rs[11451],mo[6000];
vector<vector<int>> edge;
bool go[6000];
void bfs(int s,int r){
memset(go,0,sizeof(go));
queue<int> q;
go[s]=true;
q.push(s);
for(int i=0;i<r;i++){
int qsize=q.size();
for(int j=0;j<qsize;j++){
int n=q.front();q.pop();
for(int k=0;k<edge[n].size();k++){
int ne=edge[n][k];
if(!go[ne]){
go[ne]=true;
q.push(ne);
}
}
}
}
}
int main(){
int N,K;
scanf("%d%d",&N,&K);
for(int i=0;i<N;i++){
scanf("%d%d",&cs[i],&rs[i]);
}
edge=decltype(edge)(N);
int a,b;
for(int i=0;i<K;i++){
scanf("%d%d",&a,&b);
a--;b--;
edge[a].push_back(b);
edge[b].push_back(a);
}
memset(mo,127,sizeof(mo));
mo[0]=0;
priority_queue<P,vector<P>,greater<P>> pq;
pq.push(make_pair(0,0));
while(!pq.empty()){
auto p=pq.top();pq.pop();
int at=p.second;
if(mo[at]<p.first) continue;
bfs(at,rs[at]);
for(int i=0;i<N;i++){
if(go[i] && mo[at]+cs[at]<mo[i]){
mo[i]=mo[at]+cs[at];
pq.push(make_pair(mo[i],i));
}
}
}
printf("%d\n",mo[N-1]);
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
Nukes has an integer that can be represented as the bitwise OR of one or more integers between A and B (inclusive). How many possible candidates of the value of Nukes's integer there are?
Constraints
* 1 β€ A β€ B < 2^{60}
* A and B are integers.
Input
The input is given from Standard Input in the following format:
A
B
Output
Print the number of possible candidates of the value of Nukes's integer.
Examples
Input
7
9
Output
4
Input
65
98
Output
63
Input
271828182845904523
314159265358979323
Output
68833183630578410
### Response
```cpp
#include<iostream>
using namespace std;
long long a,b,r,A;
int main()
{
cin>>a>>b;
if(a==b)
{
cout<<1;
return 0;
}
for(int i=59;i>=0;i--)
if((a>>i)!=(b>>i))
r=i,i=0;
else if(a>>i&1)
a^=((long long)1<<i),b^=((long long)1<<i);
for(int i=0;i<r;i++)
if(b>>i&1)
A=((long long)2<<i)-1;
cout<<((long long)2<<r)+A-a-max(A+1,a)+1;
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
One day Anna got the following task at school: to arrange several numbers in a circle so that any two neighboring numbers differs exactly by 1. Anna was given several numbers and arranged them in a circle to fulfill the task. Then she wanted to check if she had arranged the numbers correctly, but at this point her younger sister Maria came and shuffled all numbers. Anna got sick with anger but what's done is done and the results of her work had been destroyed. But please tell Anna: could she have hypothetically completed the task using all those given numbers?
Input
The first line contains an integer n β how many numbers Anna had (3 β€ n β€ 105). The next line contains those numbers, separated by a space. All numbers are integers and belong to the range from 1 to 109.
Output
Print the single line "YES" (without the quotes), if Anna could have completed the task correctly using all those numbers (using all of them is necessary). If Anna couldn't have fulfilled the task, no matter how hard she would try, print "NO" (without the quotes).
Examples
Input
4
1 2 3 2
Output
YES
Input
6
1 1 2 2 2 3
Output
YES
Input
6
2 4 1 1 2 2
Output
NO
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int inf = 2000000000;
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
int n;
cin >> n;
int a[n], c[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
int b[n + 1];
memset(b, 0, sizeof(b));
int first = 0;
for (int i = 0; i < n; i++) {
if (i && a[i] - a[i - 1] > 1) {
cout << "NO";
return 0;
}
if (!i || a[i] != a[i - 1]) {
first++;
}
c[i] = first;
}
int l = 1, r = first;
for (int i = 0; i < n; i++) {
b[c[i]]++;
}
a[0] = first;
b[first]--;
for (int i = 1; i < n; i++) {
int first = a[i - 1];
if (b[first - 1]) {
a[i] = first - 1;
b[first - 1]--;
} else if (b[first + 1]) {
a[i] = first + 1;
b[first + 1]--;
} else {
cout << "NO";
return 0;
}
}
cout << (abs(a[0] - a[n - 1]) == 1 ? "YES" : "NO");
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
problem
Cryptography is all the rage at xryuseix's school. Xryuseix, who lives in a grid of cities, has come up with a new cryptography to decide where to meet.
The ciphertext consists of the $ N $ character string $ S $, and the $ S_i $ character determines the direction of movement from the current location. The direction of movement is as follows.
* A ~ M: Go north one square.
* N ~ Z: Go south one square.
* a ~ m: Go east one square.
* n ~ z: Go west one square.
By the way, xryuseix wanted to tell yryuseiy-chan where to meet for a date with a ciphertext, but he noticed that the ciphertext was redundant.
For example, suppose you have the ciphertext "ANA". It goes north by $ 1 $, south by $ 1 $, and then north by $ 1 $. This is equivalent to the ciphertext that goes north by $ 1 $. , "ANA" = "A", which can be simplified. Xryuseix wanted to simplify the ciphertext so that yryuseiy would not make a detour.
So you decided to write a program to simplify the ciphertext instead of xryuseix. Note that "simplify the ciphertext" means "the shortest ciphertext that goes to the same destination as the original ciphertext." To make. "
output
The length of the ciphertext after simplification on the $ 1 $ line, output the ciphertext on the $ 2 $ line. If there are multiple possible ciphertexts as an answer, any of them may be output. Also, each line Output a line break at the end of.
Example
Input
5
ANazA
Output
1
A
### Response
```cpp
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <iostream>
#include <complex>
#include <string>
#include <algorithm>
#include <numeric>
#include <vector>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <functional>
#include <cassert>
typedef long long ll;
using namespace std;
#ifndef LOCAL
#define debug(x) ;
#else
#define debug(x) cerr << __LINE__ << " : " << #x << " = " << (x) << endl;
template <typename T1, typename T2>
ostream &operator<<(ostream &out, const pair<T1, T2> &p) {
out << "{" << p.first << ", " << p.second << "}";
return out;
}
template <typename T>
ostream &operator<<(ostream &out, const vector<T> &v) {
out << '{';
for (const T &item : v) out << item << ", ";
out << "\b\b}";
return out;
}
#endif
#define mod 1000000007 //1e9+7(prime number)
#define INF 1000000000 //1e9
#define LLINF 2000000000000000000LL //2e18
#define SIZE 200010
int main(){
int N;
string s;
cin >> N >> s;
int x = 0, y = 0;
for(int i=0; i<N; i++) {
if ('A' <= s[i] && s[i] <= 'M') y--;
if ('N' <= s[i] && s[i] <= 'Z') y++;
if ('a' <= s[i] && s[i] <= 'm') x++;
if ('n' <= s[i] && s[i] <= 'z') x--;
}
string ans;
for(int i=0; i<abs(y); i++) {
if (y < 0) ans += "A";
else ans += "Z";
}
for(int i=0; i<abs(x); i++) {
if (x > 0) ans += "a";
else ans += "z";
}
cout << ans.size() << endl;
cout << ans << endl;
return 0;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
Vasya bought the collected works of a well-known Berland poet Petya in n volumes. The volumes are numbered from 1 to n. He thinks that it does not do to arrange the book simply according to their order. Vasya wants to minimize the number of the dispositionβs divisors β the positive integers i such that for at least one j (1 β€ j β€ n) is true both: j mod i = 0 and at the same time p(j) mod i = 0, where p(j) is the number of the tome that stands on the j-th place and mod is the operation of taking the division remainder. Naturally, one volume can occupy exactly one place and in one place can stand exactly one volume.
Help Vasya β find the volume disposition with the minimum number of divisors.
Input
The first line contains number n (1 β€ n β€ 100000) which represents the number of volumes and free places.
Output
Print n numbers β the sought disposition with the minimum divisor number. The j-th number (1 β€ j β€ n) should be equal to p(j) β the number of tome that stands on the j-th place. If there are several solutions, print any of them.
Examples
Input
2
Output
2 1
Input
3
Output
1 3 2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:102400000,102400000")
template <class T>
T _max(T x, T y) {
return x > y ? x : y;
}
template <class T>
T _min(T x, T y) {
return x < y ? x : y;
}
template <class T>
T _abs(T x) {
return (x < 0) ? -x : x;
}
template <class T>
T _mod(T x, T y) {
return (x > 0) ? x % y : ((x % y) + y) % y;
}
template <class T>
void _swap(T& x, T& y) {
T t = x;
x = y;
y = t;
}
template <class T>
void getmax(T& x, T y) {
x = (y > x) ? y : x;
}
template <class T>
void getmin(T& x, T y) {
x = (x < 0 || y < x) ? y : x;
}
int TS, cas = 1;
const int M = 100000 + 5;
int n;
int ret[M];
void run() {
int i, j;
for (i = 1, j = 2; i <= n; i += 2, j += 2) ret[i] = j;
for (i = 2, j = 3; i <= n; i += 2, j += 2) ret[i] = j;
ret[n] = 1;
for (i = 1; i <= n; i++) printf("%d%c", ret[i], (i == n) ? '\n' : ' ');
}
void preSof() {}
int main() {
preSof();
while ((~scanf("%d", &n))) run();
return 0;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
There is a tree with N vertices numbered 1 through N. The i-th of the N-1 edges connects vertices a_i and b_i.
Initially, each edge is painted blue. Takahashi will convert this blue tree into a red tree, by performing the following operation N-1 times:
* Select a simple path that consists of only blue edges, and remove one of those edges.
* Then, span a new red edge between the two endpoints of the selected path.
His objective is to obtain a tree that has a red edge connecting vertices c_i and d_i, for each i.
Determine whether this is achievable.
Constraints
* 2 β€ N β€ 10^5
* 1 β€ a_i,b_i,c_i,d_i β€ N
* a_i β b_i
* c_i β d_i
* Both input graphs are trees.
Input
Input is given from Standard Input in the following format:
N
a_1 b_1
:
a_{N-1} b_{N-1}
c_1 d_1
:
c_{N-1} d_{N-1}
Output
Print `YES` if the objective is achievable; print `NO` otherwise.
Examples
Input
3
1 2
2 3
1 3
3 2
Output
YES
Input
5
1 2
2 3
3 4
4 5
3 4
2 4
1 4
1 5
Output
YES
Input
6
1 2
3 5
4 6
1 6
5 1
5 3
1 4
2 6
4 3
5 6
Output
NO
### Response
```cpp
//Great to know you're toned in
#include <bits/stdc++.h>
using namespace std;
const int N = 100100;
int n;
set<int> g[N];
int p[N];
int get(int x) {
if (p[x] == -1) {
return x;
}
return p[x] = get(p[x]);
}
int main() {
cin >> n;
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
a--; b--;
g[a].insert(b);
g[b].insert(a);
}
vector<pair<int, int>> cand;
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
a--; b--;
if (g[a].count(b)) {
cand.emplace_back(a, b);
}
g[a].insert(b);
g[b].insert(a);
}
fill_n(p, n, -1);
int cnt = 0;
while (!cand.empty()) {
int a, b;
tie(a, b) = cand.back();
cand.pop_back();
a = get(a);
b = get(b);
if (a == b) {
continue;
}
cnt++;
if (g[a].size() > g[b].size()) {
swap(a, b);
}
p[a] = b;
g[a].erase(b);
g[b].erase(a);
for (int x: g[a]) {
g[x].erase(a);
if (g[x].count(b)) {
cand.emplace_back(x, b);
}
g[x].insert(b);
g[b].insert(x);
}
set<int>().swap(g[a]);
}
if (cnt == n - 1) {
cout << "YES";
} else {
cout << "NO";
}
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
You are given a forest β an undirected graph with n vertices such that each its connected component is a tree.
The diameter (aka "longest shortest path") of a connected undirected graph is the maximum number of edges in the shortest path between any pair of its vertices.
You task is to add some edges (possibly zero) to the graph so that it becomes a tree and the diameter of the tree is minimal possible.
If there are multiple correct answers, print any of them.
Input
The first line contains two integers n and m (1 β€ n β€ 1000, 0 β€ m β€ n - 1) β the number of vertices of the graph and the number of edges, respectively.
Each of the next m lines contains two integers v and u (1 β€ v, u β€ n, v β u) β the descriptions of the edges.
It is guaranteed that the given graph is a forest.
Output
In the first line print the diameter of the resulting tree.
Each of the next (n - 1) - m lines should contain two integers v and u (1 β€ v, u β€ n, v β u) β the descriptions of the added edges.
The resulting graph should be a tree and its diameter should be minimal possible.
For m = n - 1 no edges are added, thus the output consists of a single integer β diameter of the given tree.
If there are multiple correct answers, print any of them.
Examples
Input
4 2
1 2
2 3
Output
2
4 2
Input
2 0
Output
1
1 2
Input
3 2
1 3
2 3
Output
2
Note
In the first example adding edges (1, 4) or (3, 4) will lead to a total diameter of 3. Adding edge (2, 4), however, will make it 2.
Edge (1, 2) is the only option you have for the second example. The diameter is 1.
You can't add any edges in the third example. The diameter is already 2.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e3 + 100;
int N, M;
bitset<MAXN> v;
vector<int> a[MAXN];
;
int p[MAXN], d[MAXN];
queue<int> x;
array<int, 2> far(int n) {
while (not x.empty()) x.pop();
x.push(n);
int r;
p[n] = -1, d[n] = 0;
while (not x.empty()) {
r = x.front();
x.pop();
v[r] = true;
for (int u : a[r]) {
if (p[r] == u) continue;
p[u] = r, d[u] = d[r] + 1;
x.push(u);
}
}
return {r, d[r]};
}
array<int, 2> center(int n) {
array<int, 2> s = far(far(n).at(0));
int r = s.at(0);
for (int i = 0; i << 1 < s.at(1); i++, r = p[r])
;
return {r, s.at(1)};
}
vector<array<int, 2> > T;
int max(int a, int b, int c) {
if (a < b) a = b;
if (a < c) a = c;
return a;
}
int main() {
scanf("%d%d", &N, &M);
for (int i = 0, u, w; i < M; i++) {
scanf("%d%d", &u, &w);
a[u].push_back(w);
a[w].push_back(u);
}
if (M + 1 == N) {
printf("%d\n", far(far(1).at(0)).at(1));
return 0;
}
for (int i = 1; i <= N; i++) v[i] = false;
for (int i = 1; i <= N; i++)
if (not v[i]) T.push_back(center(i));
assert(T.size() > 1);
sort(T.begin(), T.end(), [](const array<int, 2>& z, const array<int, 2>& y) {
return z.at(1) > y.at(1);
});
if (T.size() == 2) {
printf(
"%d\n%d %d\n",
max(T[0].at(1), ((1 + T[0].at(1)) >> 1) + 1 + ((1 + T[1].at(1)) >> 1)),
T[0].at(0), T[1].at(0));
} else {
printf("%d\n", max(T[0].at(1),
((1 + T[0].at(1)) >> 1) + 1 + ((1 + T[1].at(1)) >> 1),
((1 + T[1].at(1)) >> 1) + 2 + ((1 + T[2].at(1)) >> 1)));
for (int i = 1; i < T.size(); i++)
printf("%d %d\n", T[0].at(0), T[i].at(0));
}
return 0;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
A kindergarten teacher Natalia Pavlovna has invented a new ball game. This game not only develops the children's physique, but also teaches them how to count.
The game goes as follows. Kids stand in circle. Let's agree to think of the children as numbered with numbers from 1 to n clockwise and the child number 1 is holding the ball. First the first child throws the ball to the next one clockwise, i.e. to the child number 2. Then the child number 2 throws the ball to the next but one child, i.e. to the child number 4, then the fourth child throws the ball to the child that stands two children away from him, i.e. to the child number 7, then the ball is thrown to the child who stands 3 children away from the child number 7, then the ball is thrown to the child who stands 4 children away from the last one, and so on. It should be mentioned that when a ball is thrown it may pass the beginning of the circle. For example, if n = 5, then after the third throw the child number 2 has the ball again. Overall, n - 1 throws are made, and the game ends.
The problem is that not all the children get the ball during the game. If a child doesn't get the ball, he gets very upset and cries until Natalia Pavlovna gives him a candy. That's why Natalia Pavlovna asks you to help her to identify the numbers of the children who will get the ball after each throw.
Input
The first line contains integer n (2 β€ n β€ 100) which indicates the number of kids in the circle.
Output
In the single line print n - 1 numbers which are the numbers of children who will get the ball after each throw. Separate the numbers by spaces.
Examples
Input
10
Output
2 4 7 1 6 2 9 7 6
Input
3
Output
2 1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int p = 1;
for (int i = 1; i < n; i++) {
p += i;
p %= n;
if (!p) p = n;
printf("%d ", p);
}
}
``` |
### Prompt
Generate a CPP solution to the following problem:
Create a program that inputs the test result data of the visual acuity test and outputs the number of people who apply to each judgment based on the following visual acuity judgment table for each of the left and right eyesight.
Judgment | Sight
--- | ---
A | 1.1 or above
B | 0.6 or more and less than 1.1
C | 0.2 or more and less than 0.6
D | less than 0.2
Input
The input is given in the following format:
l1 r1
l2 r2
l3 r3
::
::
On line i, the real number li, which represents the left visual acuity of the i-th person, and the real number ri, which represents the right visual acuity, are given, separated by blanks. However, visual acuity is 0.1 or more and 2.0 or less, and is given in 0.1 increments.
The number of lines of input does not exceed 40.
Output
Please output the judgment table in the following format.
Line 1 Left eyesight is the number of people A Right eyesight is the number of people (separated by blanks)
2nd line The number of people whose left eyesight is B The number of people whose right eyesight is B (separated by blanks)
3rd line The number of people whose left eyesight is C
4th line Number of people with left eyesight D Number of people with right eyesight D (separated by blanks)
Example
Input
1.0 1.2
0.8 1.5
1.2 0.7
2.0 2.0
Output
2 3
2 1
0 0
0 0
### Response
```cpp
#include<iostream>
using namespace std;
int main(){
double left, right;
int A[2] = {};
int B[2] = {};
int C[2] = {};
int D[2] = {};
while( cin >> left >> right ) {
if( left >= 1.1) A[0] ++;
if( 0.6 <= left && left < 1.1) B[0] ++;
if( 0.2 <= left && left < 0.6) C[0] ++;
if( left < 0.2) D[0] ++;
if( right >= 1.1) A[1] ++;
if( 0.6 <= right && right < 1.1) B[1] ++;
if( 0.2 <= right && right < 0.6) C[1] ++;
if( right < 0.2) D[1] ++;
}
cout << A[0] << " " << A[1] << "\n";
cout << B[0] << " " << B[1] << "\n";
cout << C[0] << " " << C[1] << "\n";
cout << D[0] << " " << D[1] << "\n";
return 0;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
There are N cubes stacked vertically on a desk.
You are given a string S of length N. The color of the i-th cube from the bottom is red if the i-th character in S is `0`, and blue if that character is `1`.
You can perform the following operation any number of times: choose a red cube and a blue cube that are adjacent, and remove them. Here, the cubes that were stacked on the removed cubes will fall down onto the object below them.
At most how many cubes can be removed?
Constraints
* 1 \leq N \leq 10^5
* |S| = N
* Each character in S is `0` or `1`.
Input
Input is given from Standard Input in the following format:
S
Output
Print the maximum number of cubes that can be removed.
Examples
Input
0011
Output
4
Input
11011010001011
Output
12
Input
0
Output
0
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
string s;
cin>>s;
int a=0,b=0;
for(int i=0;i<(int)s.size();i++){
if(s[i]=='0')a++;
else b++;
}
cout<<min(a,b)*2<<endl;
return 0;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
DZY has a sequence a, consisting of n integers.
We'll call a sequence ai, ai + 1, ..., aj (1 β€ i β€ j β€ n) a subsegment of the sequence a. The value (j - i + 1) denotes the length of the subsegment.
Your task is to find the longest subsegment of a, such that it is possible to change at most one number (change one number to any integer you want) from the subsegment to make the subsegment strictly increasing.
You only need to output the length of the subsegment you find.
Input
The first line contains integer n (1 β€ n β€ 105). The next line contains n integers a1, a2, ..., an (1 β€ ai β€ 109).
Output
In a single line print the answer to the problem β the maximum length of the required subsegment.
Examples
Input
6
7 2 3 1 5 6
Output
5
Note
You can choose subsegment a2, a3, a4, a5, a6 and change its 3rd element (that is a4) to 4.
### Response
```cpp
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:66777216")
using namespace std;
const double pi = 3.1415926535897932384626433832795028841971;
const double EPS = 1E-9;
const signed long long INF64 = (signed long long)1E18;
const int INF = 1000000000;
static inline bool get(int &v) {
int s = 1, c;
while (!isdigit(c = getchar()) && c != '-') {
if (c == EOF) break;
}
if (c == EOF) return 0;
if (c == '-')
s = 0, v = 0;
else
v = c ^ 48;
for (; isdigit(c = getchar()); v = (v << 1) + (v << 3) + (c ^ 48))
;
v = (s ? v : -v);
return 1;
}
const int maxn = 100005;
int e[maxn];
int up[maxn], down[maxn];
void run() {
ios::sync_with_stdio(false);
int n, ans = 1;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> e[i];
}
up[0] = 1;
for (int i = 1; i < n; i++) {
if (e[i] > e[i - 1])
up[i] = up[i - 1] + 1;
else
up[i] = 1;
ans = max(ans, up[i]);
}
down[n - 1] = 1;
for (int i = n - 2; i >= 0; i--) {
if (e[i] < e[i + 1])
down[i] = down[i + 1] + 1;
else
down[i] = 1;
ans = max(ans, down[i]);
}
if (n > 1) {
ans = max(up[n - 2] + 1, ans);
ans = max(down[1] + 1, ans);
}
for (int i = 1; i < n - 1; i++) {
ans = max(ans, down[i + 1] + 1);
ans = max(ans, up[i - 1] + 1);
if (e[i - 1] + 1 < e[i + 1]) {
ans = max(ans, up[i - 1] + down[i + 1] + 1);
}
}
cout << ans << endl;
}
int main() {
run();
return 0;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
Note that the only difference between String Transformation 1 and String Transformation 2 is in the move Koa does. In this version the letter y Koa selects must be strictly greater alphabetically than x (read statement for better understanding). You can make hacks in these problems independently.
Koa the Koala has two strings A and B of the same length n (|A|=|B|=n) consisting of the first 20 lowercase English alphabet letters (ie. from a to t).
In one move Koa:
1. selects some subset of positions p_1, p_2, β¦, p_k (k β₯ 1; 1 β€ p_i β€ n; p_i β p_j if i β j) of A such that A_{p_1} = A_{p_2} = β¦ = A_{p_k} = x (ie. all letters on this positions are equal to some letter x).
2. selects a letter y (from the first 20 lowercase letters in English alphabet) such that y>x (ie. letter y is strictly greater alphabetically than x).
3. sets each letter in positions p_1, p_2, β¦, p_k to letter y. More formally: for each i (1 β€ i β€ k) Koa sets A_{p_i} = y.
Note that you can only modify letters in string A.
Koa wants to know the smallest number of moves she has to do to make strings equal to each other (A = B) or to determine that there is no way to make them equal. Help her!
Input
Each test contains multiple test cases. The first line contains t (1 β€ t β€ 10) β the number of test cases. Description of the test cases follows.
The first line of each test case contains one integer n (1 β€ n β€ 10^5) β the length of strings A and B.
The second line of each test case contains string A (|A|=n).
The third line of each test case contains string B (|B|=n).
Both strings consists of the first 20 lowercase English alphabet letters (ie. from a to t).
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case:
Print on a single line the smallest number of moves she has to do to make strings equal to each other (A = B) or -1 if there is no way to make them equal.
Example
Input
5
3
aab
bcc
4
cabc
abcb
3
abc
tsr
4
aabd
cccd
5
abcbd
bcdda
Output
2
-1
3
2
-1
Note
* In the 1-st test case Koa:
1. selects positions 1 and 2 and sets A_1 = A_2 = b (\color{red}{aa}b β \color{blue}{bb}b).
2. selects positions 2 and 3 and sets A_2 = A_3 = c (b\color{red}{bb} β b\color{blue}{cc}).
* In the 2-nd test case Koa has no way to make string A equal B.
* In the 3-rd test case Koa:
1. selects position 1 and sets A_1 = t (\color{red}{a}bc β \color{blue}{t}bc).
2. selects position 2 and sets A_2 = s (t\color{red}{b}c β t\color{blue}{s}c).
3. selects position 3 and sets A_3 = r (ts\color{red}{c} β ts\color{blue}{r}).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
template <typename T>
void chkmax(T &x, T y) {
x = max(x, y);
}
template <typename T>
void chkmin(T &x, T y) {
x = min(x, y);
}
template <typename T>
void read(T &x) {
x = 0;
int f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -f;
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
x *= f;
}
int n;
char s[MAXN], t[MAXN];
int main() {
int T;
read(T);
while (T--) {
read(n);
scanf("\n%s", s + 1);
scanf("\n%s", t + 1);
int ans = 0;
for (int i = 1; i <= n; i++)
if (s[i] > t[i]) ans = -1;
if (ans == -1) {
puts("-1");
continue;
}
while (true) {
char c = 'z', d = 'z';
for (int i = 1; i <= n; i++)
if (s[i] < t[i]) {
if (s[i] < c) {
c = s[i];
d = t[i];
} else if (s[i] == c)
chkmin(d, t[i]);
}
if (c == 'z') break;
ans++;
for (int i = 1; i <= n; i++)
if (s[i] < t[i] && s[i] == c) s[i] = d;
}
printf("%d\n", ans);
}
return 0;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
The fact that any positive integer has a representation as the sum of at most four positive squares (i.e. squares of positive integers) is known as Lagrangeβs Four-Square Theorem. The first published proof of the theorem was given by Joseph-Louis Lagrange in 1770. Your mission however is not to explain the original proof nor to discover a new proof but to show that the theorem holds for some specific numbers by counting how many such possible representations there are.
For a given positive integer n, you should report the number of all representations of n as the sum of at most four positive squares. The order of addition does not matter, e.g. you should consider 42 + 32 and 32 + 42 are the same representation.
For example, letβs check the case of 25. This integer has just three representations 12 +22 +22 +42 , 32 + 42 , and 52 . Thus you should report 3 in this case. Be careful not to count 42 + 32 and 32 + 42 separately.
Input
The input is composed of at most 255 lines, each containing a single positive integer less than 215 , followed by a line containing a single zero. The last line is not a part of the input data.
Output
The output should be composed of lines, each containing a single integer. No other characters should appear in the output.
The output integer corresponding to the input integer n is the number of all representations of n as the sum of at most four positive squares.
Example
Input
1
25
2003
211
20007
0
Output
1
3
48
7
738
### Response
```cpp
#include <iostream>
/*???????????????????????Β§??????????????Β°?????????????????????
???????????????????????????????????Β°??Β§dp[0][sq]???????????Β£??\???????????????
sq??\????????Β°??Β¨?????????????????????????????Β°???????Β¨???????????????????
2????????\????????Β’????????????????????????????????Β§?????????????Β¨????????????Β°??????
*/
using namespace std;
const int N = 32770;
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int dp[4][N+1] = {};
for(int i = 1;i*i <= N;i++){
for(int j = 0;j < 3;j++){
int sq = i*i;
if(j == 0)dp[0][sq] = 1;
for(int k = 1;k <= N;k++){
if(k + sq >= N)continue;
dp[j + 1][k + sq] += dp[j][k];
}
}
}
int n;
while(cin >> n,n){
cout << dp[0][n] + dp[1][n] + dp[2][n] + dp[3][n] << endl;
}
return 0;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
It's holiday. Mashmokh and his boss, Bimokh, are playing a game invented by Mashmokh.
In this game Mashmokh writes sequence of n distinct integers on the board. Then Bimokh makes several (possibly zero) moves. On the first move he removes the first and the second integer from from the board, on the second move he removes the first and the second integer of the remaining sequence from the board, and so on. Bimokh stops when the board contains less than two numbers. When Bimokh removes numbers x and y from the board, he gets gcd(x, y) points. At the beginning of the game Bimokh has zero points.
Mashmokh wants to win in the game. For this reason he wants his boss to get exactly k points in total. But the guy doesn't know how choose the initial sequence in the right way.
Please, help him. Find n distinct integers a1, a2, ..., an such that his boss will score exactly k points. Also Mashmokh can't memorize too huge numbers. Therefore each of these integers must be at most 109.
Input
The first line of input contains two space-separated integers n, k (1 β€ n β€ 105; 0 β€ k β€ 108).
Output
If such sequence doesn't exist output -1 otherwise output n distinct space-separated integers a1, a2, ..., an (1 β€ ai β€ 109).
Examples
Input
5 2
Output
1 2 3 4 5
Input
5 3
Output
2 4 3 7 1
Input
7 2
Output
-1
Note
gcd(x, y) is greatest common divisor of x and y.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
if (n == 1 && k == 0) {
cout << "1\n";
return 0;
}
if (n / 2 > k) {
cout << "-1" << '\n';
return 0;
}
if (n == 1 && k > 1) {
cout << "-1\n";
return 0;
}
if (n == 1 && k == 1) {
cout << "-1\n";
return 0;
}
int a = 0, b = 0;
if (n > 1) {
if (n / 2 != k) {
a = k - n / 2 + 1;
b = 2 * a;
} else {
a = 2;
b = 3;
}
cout << a << ' ' << b;
n -= 2;
}
int i = 0;
for (i = 2; n > 1; i += 2) {
if (i == a || (i + 1) == a || i == b || (i + 1) == b) {
i--;
continue;
}
cout << ' ' << i << ' ' << i + 1;
n -= 2;
}
if (n == 1) {
if (a == 1 || b == 1) {
while (1) {
if (a != i && b != i) {
cout << ' ' << i;
break;
}
i++;
}
} else
cout << ' ' << '1';
}
cout << '\n';
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
Let's define a non-oriented connected graph of n vertices and n - 1 edges as a beard, if all of its vertices except, perhaps, one, have the degree of 2 or 1 (that is, there exists no more than one vertex, whose degree is more than two). Let us remind you that the degree of a vertex is the number of edges that connect to it.
Let each edge be either black or white. Initially all edges are black.
You are given the description of the beard graph. Your task is to analyze requests of the following types:
* paint the edge number i black. The edge number i is the edge that has this number in the description. It is guaranteed that by the moment of this request the i-th edge is white
* paint the edge number i white. It is guaranteed that by the moment of this request the i-th edge is black
* find the length of the shortest path going only along the black edges between vertices a and b or indicate that no such path exists between them (a path's length is the number of edges in it)
The vertices are numbered with integers from 1 to n, and the edges are numbered with integers from 1 to n - 1.
Input
The first line of the input contains an integer n (2 β€ n β€ 105) β the number of vertices in the graph. Next n - 1 lines contain edges described as the numbers of vertices vi, ui (1 β€ vi, ui β€ n, vi β ui) connected by this edge. It is guaranteed that the given graph is connected and forms a beard graph, and has no self-loops or multiple edges.
The next line contains an integer m (1 β€ m β€ 3Β·105) β the number of requests. Next m lines contain requests in the following form: first a line contains an integer type, which takes values ββfrom 1 to 3, and represents the request type.
If type = 1, then the current request is a request to paint the edge black. In this case, in addition to number type the line should contain integer id (1 β€ id β€ n - 1), which represents the number of the edge to paint.
If type = 2, then the current request is a request to paint the edge white, its form is similar to the previous request.
If type = 3, then the current request is a request to find the distance. In this case, in addition to type, the line should contain two integers a, b (1 β€ a, b β€ n, a can be equal to b) β the numbers of vertices, the distance between which must be found.
The numbers in all lines are separated by exactly one space. The edges are numbered in the order in which they are given in the input.
Output
For each request to "find the distance between vertices a and b" print the result. If there is no path going only along the black edges between vertices a and b, then print "-1" (without the quotes). Print the results in the order of receiving the requests, separate the numbers with spaces or line breaks.
Examples
Input
3
1 2
2 3
7
3 1 2
3 1 3
3 2 3
2 2
3 1 2
3 1 3
3 2 3
Output
1
2
1
1
-1
-1
Input
6
1 5
6 4
2 3
3 5
5 6
6
3 3 4
2 5
3 2 6
3 1 2
2 3
3 3 1
Output
3
-1
3
2
Note
In the first sample vertices 1 and 2 are connected with edge number 1, and vertices 2 and 3 are connected with edge number 2. Before the repainting edge number 2 each vertex is reachable from each one along the black edges. Specifically, the shortest path between 1 and 3 goes along both edges.
If we paint edge number 2 white, vertex 3 will end up cut off from other vertices, that is, no path exists from it to any other vertex along the black edges.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct node {
int y, w, next;
} path[100005 * 2];
int first[100005], p;
inline void add(int x, int y, int w) {
path[p].y = y;
path[p].w = w;
path[p].next = first[x];
first[x] = p++;
}
int fa[100005][18], dep[100005], bg[100005], ed[100005], idx;
int stn[100005];
void dfs(int x, int r, int d) {
fa[x][0] = r;
dep[x] = d;
for (int i = 1; i < 18; i++) fa[x][i] = fa[fa[x][i - 1]][i - 1];
int v;
bg[x] = ++idx;
for (int i = first[x]; i != -1; i = path[i].next) {
v = path[i].y;
if (v == r) continue;
stn[path[i].w] = v;
dfs(v, x, d + 1);
}
ed[x] = idx;
}
int n;
int d[100005 * 2];
inline int lowbit(int x) { return x & (-x); }
void update(int x, int data) {
for (int i = x; i <= idx; i += lowbit(i)) d[i] += data;
}
int query(int x) {
int ret = 0;
for (int i = x; i > 0; i -= lowbit(i)) ret += d[i];
return ret;
}
int lca(int x, int y) {
if (dep[x] > dep[y]) swap(x, y);
int d = dep[y] - dep[x];
for (int i = 17; i >= 0; i--)
if (d & (1 << i)) y = fa[y][i];
if (x == y) return y;
for (int i = 17; i >= 0; i--)
if (fa[x][i] != fa[y][i]) {
x = fa[x][i];
y = fa[y][i];
}
return fa[x][0];
}
void solve(int x, int y) {
int fa = lca(x, y);
int s1 = query(bg[x]) - query(bg[fa]);
int s2 = query(bg[y]) - query(bg[fa]);
if (s1 != dep[x] - dep[fa] || s2 != dep[y] - dep[fa])
printf("-1\n");
else
printf("%d\n", dep[x] - dep[fa] + dep[y] - dep[fa]);
}
int state[100005];
int main() {
int x, y, f;
while (scanf("%d", &n) != EOF) {
memset(first, -1, sizeof(first));
p = 0;
for (int i = 1; i < n; i++) {
scanf("%d %d", &x, &y);
add(x, y, i);
add(y, x, i);
}
idx = 0;
dfs(1, 0, 0);
memset(d, 0, sizeof(d));
for (int i = 1; i < n; i++) {
update(bg[stn[i]], 1);
update(ed[stn[i]] + 1, -1);
state[i] = 1;
}
int m;
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
scanf("%d", &f);
if (f == 1) {
scanf("%d", &x);
if (state[x] == 0) {
state[x] = 1;
update(bg[stn[x]], 1);
update(ed[stn[x]] + 1, -1);
}
} else if (f == 2) {
scanf("%d", &x);
if (state[x] == 1) {
state[x] = 0;
update(bg[stn[x]], -1);
update(ed[stn[x]] + 1, 1);
}
} else {
scanf("%d %d", &x, &y);
solve(x, y);
}
}
}
return 0;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
Medicine faculty of Berland State University has just finished their admission campaign. As usual, about 80\% of applicants are girls and majority of them are going to live in the university dormitory for the next 4 (hopefully) years.
The dormitory consists of n rooms and a single mouse! Girls decided to set mouse traps in some rooms to get rid of the horrible monster. Setting a trap in room number i costs c_i burles. Rooms are numbered from 1 to n.
Mouse doesn't sit in place all the time, it constantly runs. If it is in room i in second t then it will run to room a_i in second t + 1 without visiting any other rooms inbetween (i = a_i means that mouse won't leave room i). It's second 0 in the start. If the mouse is in some room with a mouse trap in it, then the mouse get caught into this trap.
That would have been so easy if the girls actually knew where the mouse at. Unfortunately, that's not the case, mouse can be in any room from 1 to n at second 0.
What it the minimal total amount of burles girls can spend to set the traps in order to guarantee that the mouse will eventually be caught no matter the room it started from?
Input
The first line contains as single integers n (1 β€ n β€ 2 β
10^5) β the number of rooms in the dormitory.
The second line contains n integers c_1, c_2, ..., c_n (1 β€ c_i β€ 10^4) β c_i is the cost of setting the trap in room number i.
The third line contains n integers a_1, a_2, ..., a_n (1 β€ a_i β€ n) β a_i is the room the mouse will run to the next second after being in room i.
Output
Print a single integer β the minimal total amount of burles girls can spend to set the traps in order to guarantee that the mouse will eventually be caught no matter the room it started from.
Examples
Input
5
1 2 3 2 10
1 3 4 3 3
Output
3
Input
4
1 10 2 10
2 4 2 2
Output
10
Input
7
1 1 1 1 1 1 1
2 2 2 3 6 7 6
Output
2
Note
In the first example it is enough to set mouse trap in rooms 1 and 4. If mouse starts in room 1 then it gets caught immideately. If mouse starts in any other room then it eventually comes to room 4.
In the second example it is enough to set mouse trap in room 2. If mouse starts in room 2 then it gets caught immideately. If mouse starts in any other room then it runs to room 2 in second 1.
Here are the paths of the mouse from different starts from the third example:
* 1 β 2 β 2 β ...;
* 2 β 2 β ...;
* 3 β 2 β 2 β ...;
* 4 β 3 β 2 β 2 β ...;
* 5 β 6 β 7 β 6 β ...;
* 6 β 7 β 6 β ...;
* 7 β 6 β 7 β ...;
So it's enough to set traps in rooms 2 and 6.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long n, c[300000], sl, d[300000], e[300000], cnt, Low[300000], Num[300000],
Count, SL[300000];
vector<long long> a[200005], v[200005];
bool fre[200100];
stack<long long> st;
void visit(int u) {
Low[u] = Num[u] = ++cnt;
st.push(u);
for (int i = 0; i < a[u].size(); i++) {
long long v = a[u][i];
if (Num[v])
Low[u] = min(Low[u], Num[v]);
else {
visit(v);
Low[u] = min(Low[u], Low[v]);
}
}
if (Num[u] == Low[u]) {
Count++;
e[Count] = 1e12;
int v, sl2 = 0;
do {
v = st.top();
st.pop();
Num[v] = Low[v] = 1e12;
d[v] = Count;
e[Count] = min(e[Count], c[v]);
sl2++;
} while (v != u);
SL[Count] = sl2;
}
}
void dfs(long long u) {
for (int i = 0; i < a[u].size(); i++) {
long long v = a[u][i];
if (d[v] != d[u]) {
if (SL[d[v]] > 1 && SL[d[u]] > 1) e[u] = min(e[u], e[v]);
d[v] = d[u], dfs(v);
}
}
}
int main() {
cnt = 0;
memset(fre, true, sizeof fre);
cin >> n;
for (int i = 1; i <= n; i++) cin >> c[i];
for (int i = 1; i <= n; i++) {
long long foo;
cin >> foo;
if (i != foo) a[foo].push_back(i);
}
long long res = 0;
for (int i = 1; i <= n; i++)
if (!Num[i]) visit(i);
memset(fre, true, sizeof fre);
for (int i = 1; i <= n; i++) dfs(i);
for (int i = 1; i <= n; i++) {
if (fre[d[i]]) res += e[d[i]], fre[d[i]] = false;
}
cout << res;
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Petya loves lucky numbers. We all know that lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Petya wonders eagerly what minimum lucky number has the sum of digits equal to n. Help him cope with the task.
Input
The single line contains an integer n (1 β€ n β€ 106) β the sum of digits of the required lucky number.
Output
Print on the single line the result β the minimum lucky number, whose sum of digits equals n. If such number does not exist, print -1.
Examples
Input
11
Output
47
Input
10
Output
-1
### Response
```cpp
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
const double pi = acos(-1.0);
const int inf = (int)1e9;
const double eps = 1e-6;
const int ss = (int)1e6 + 3;
const int base = inf;
bool pred(const pair<int, int>& i, const pair<int, int>& j) {
if (i.first == j.first) {
return i.second > j.second;
} else {
return i.first > j.first;
}
}
bool pred1(const string& i, const string& j) { return i.size() > j.size(); }
int main() {
int n;
cin >> n;
int x = 0;
int y = 0;
int mn = inf;
int kol = 0;
while (n >= 0) {
if (n % 4 == 0) {
int now = n / 4;
now += kol;
if (now < mn) {
mn = now;
x = n / 4;
y = kol;
}
if (now == mn && kol < y) {
x = n / 4;
y = kol;
}
}
++kol;
n -= 7;
}
if (mn == inf) {
cout << -1;
} else {
for (int i = 0; i < x; ++i) cout << 4;
for (int i = 0; i < y; ++i) cout << 7;
}
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
Arkady's code contains n variables. Each variable has a unique name consisting of lowercase English letters only. One day Arkady decided to shorten his code.
He wants to replace each variable name with its non-empty prefix so that these new names are still unique (however, a new name of some variable can coincide with some old name of another or same variable). Among such possibilities he wants to find the way with the smallest possible total length of the new names.
A string a is a prefix of a string b if you can delete some (possibly none) characters from the end of b and obtain a.
Please find this minimum possible total length of new names.
Input
The first line contains a single integer n (1 β€ n β€ 10^5) β the number of variables.
The next n lines contain variable names, one per line. Each name is non-empty and contains only lowercase English letters. The total length of these strings is not greater than 10^5. The variable names are distinct.
Output
Print a single integer β the minimum possible total length of new variable names.
Examples
Input
3
codeforces
codehorses
code
Output
6
Input
5
abba
abb
ab
aa
aacada
Output
11
Input
3
telegram
digital
resistance
Output
3
Note
In the first example one of the best options is to shorten the names in the given order as "cod", "co", "c".
In the second example we can shorten the last name to "aac" and the first name to "a" without changing the other names.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 77, L = 26;
int n, S[N][L], t = 1, H[N], A;
char s[N];
multiset<int> D[N];
void insert() {
int m = strlen(s), id = 1;
for (int i = 0; i < m; i++) {
if (S[id][s[i] - 'a'] == 0) {
++t;
S[id][s[i] - 'a'] = t;
}
id = S[id][s[i] - 'a'];
}
H[id]++;
A += m;
}
void dfs(int v) {
for (int i = 0; i < L; i++) {
if (S[v][i] == 0) {
continue;
}
dfs(S[v][i]);
for (auto x : D[S[v][i]]) {
D[v].insert(x + 1);
}
}
if (H[v]) {
D[v].insert(0);
} else if (v > 1) {
int P = *D[v].rbegin();
A -= P;
D[v].erase(D[v].find(P));
D[v].insert(0);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%s", &s);
insert();
}
dfs(1);
printf("%d\n", A);
return 0;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
Vasya follows a basketball game and marks the distances from which each team makes a throw. He knows that each successful throw has value of either 2 or 3 points. A throw is worth 2 points if the distance it was made from doesn't exceed some value of d meters, and a throw is worth 3 points if the distance is larger than d meters, where d is some non-negative integer.
Vasya would like the advantage of the points scored by the first team (the points of the first team minus the points of the second team) to be maximum. For that he can mentally choose the value of d. Help him to do that.
Input
The first line contains integer n (1 β€ n β€ 2Β·105) β the number of throws of the first team. Then follow n integer numbers β the distances of throws ai (1 β€ ai β€ 2Β·109).
Then follows number m (1 β€ m β€ 2Β·105) β the number of the throws of the second team. Then follow m integer numbers β the distances of throws of bi (1 β€ bi β€ 2Β·109).
Output
Print two numbers in the format a:b β the score that is possible considering the problem conditions where the result of subtraction a - b is maximum. If there are several such scores, find the one in which number a is maximum.
Examples
Input
3
1 2 3
2
5 6
Output
9:6
Input
5
6 7 8 9 10
5
1 2 3 4 5
Output
15:10
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
vector<int> va(n);
for (int i = 0; i < n; ++i) cin >> va[i];
int m;
cin >> m;
vector<int> vb(m);
for (int i = 0; i < m; ++i) cin >> vb[i];
sort(va.begin(), va.end());
sort(vb.begin(), vb.end());
int best = INT_MIN;
int sela, selb;
for (int i = 0; i <= n; ++i) {
int a = 2 * i + 3 * (n - i);
int j = i < n ? lower_bound(vb.begin(), vb.end(), va[i]) - vb.begin() : m;
int b = 2 * j + 3 * (m - j);
if (a - b > best) {
best = a - b;
sela = a;
selb = b;
}
}
cout << sela << ":" << selb << endl;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
problem
A city in Canada where JOI lives is divided into a grid pattern by w roads that extend straight in the north-south direction and h roads that extend straight in the east-west direction.
The w roads in the north-south direction are numbered 1, 2, ..., w in order from the west. In addition, h roads in the east-west direction are numbered 1, 2, ..., h in order from the south. The intersection of the i-th north-south road from the west and the j-th east-west road from the south is represented by (i, j).
JOI lives near the intersection (1, 1) and drives to a company near the intersection (w, h). Cars can only move along the road. JOI travels only to the east or north to shorten his commute time. The city also has the following traffic rules to reduce traffic accidents:
* A car that turns at an intersection cannot turn at the intersection immediately after that.
That is, it is not permissible to go one block after turning at an intersection and turn again. At this time, how many possible commuting routes for Mr. JOI?
Given w and h, create a program that outputs the remainder of JOI's number of commuting routes divided by 100000.
input
The input consists of multiple datasets. Each dataset consists of one line, and two integers w, h (2 β€ w β€ 100, 2 β€ h β€ 100) are written, separated by a blank. w represents the number of roads in the north-south direction, and h represents the number of roads in the east-west direction.
When both w and h are 0, it indicates the end of input. The number of data sets does not exceed 5.
output
For each data set, the remainder of JOI's number of commuting routes divided by 100000 is output on one line.
Example
Input
3 4
15 15
0 0
Output
5
43688
### Response
```cpp
#include<iostream>
#include<cstdio>
using namespace std;
int main(){
static int w,h,dp[100+2][100+2][2][2];
for(int i=0;i<102;i++){
for(int j=0;j<102;j++){
for(int k=0;k<4;k++){
dp[i][j][(k-k%2)/2][k%2]=0;
}
}
}
dp[3][1][0][0]=1;
dp[2][2][0][1]=1;
dp[2][2][1][0]=1;
dp[1][3][1][1]=1;
for(int i=1;i<101;i++){
for(int j=max(1,5-i);j<101;j++){
dp[i][j][0][0]=(dp[i-1][j][0][0]+dp[i-1][j][1][0])%100000;
dp[i][j][0][1]=dp[i][j-1][0][0]%100000;
dp[i][j][1][0]=dp[i-1][j][1][1]%100000;
dp[i][j][1][1]=(dp[i][j-1][0][1]+dp[i][j-1][1][1])%100000;
}
}
while(1){
scanf("%d%d",&w,&h);
if(w==0&&h==0)break;
printf("%d\n",(dp[w][h][0][0]+dp[w][h][0][1]+dp[w][h][1][0]+dp[w][h][1][1])%100000);
}
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
A programming competition site AtCode regularly holds programming contests.
The next contest on AtCode is called ABC, which is rated for contestants with ratings less than 1200.
The contest after the ABC is called ARC, which is rated for contestants with ratings less than 2800.
The contest after the ARC is called AGC, which is rated for all contestants.
Takahashi's rating on AtCode is R. What is the next contest rated for him?
Constraints
* 0 β€ R β€ 4208
* R is an integer.
Input
Input is given from Standard Input in the following format:
R
Output
Print the name of the next contest rated for Takahashi (`ABC`, `ARC` or `AGC`).
Examples
Input
1199
Output
ABC
Input
1200
Output
ARC
Input
4208
Output
AGC
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
int n;
cin>>n;
if(n<1200) cout<<"ABC";
else if(n>=2800) cout<<"AGC";
else cout<<"ARC";
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
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;
int main() {
int n, ans1 = 0, ans2 = 0;
cin >> n;
int arr[2 * n];
for (int i = 0; i < 2 * n; i++) cin >> arr[i];
sort(arr, arr + (2 * n));
for (int i = 0; i < 2 * n; i++) {
if (i < n)
ans1 += arr[i];
else
ans2 += arr[i];
}
if (ans1 == ans2)
cout << "-1";
else
for (int i = 0; i < 2 * n; i++) cout << arr[i] << " ";
return 0;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
Paladin Manao caught the trail of the ancient Book of Evil in a swampy area. This area contains n settlements numbered from 1 to n. Moving through the swamp is very difficult, so people tramped exactly n - 1 paths. Each of these paths connects some pair of settlements and is bidirectional. Moreover, it is possible to reach any settlement from any other one by traversing one or several paths.
The distance between two settlements is the minimum number of paths that have to be crossed to get from one settlement to the other one. Manao knows that the Book of Evil has got a damage range d. This means that if the Book of Evil is located in some settlement, its damage (for example, emergence of ghosts and werewolves) affects other settlements at distance d or less from the settlement where the Book resides.
Manao has heard of m settlements affected by the Book of Evil. Their numbers are p1, p2, ..., pm. Note that the Book may be affecting other settlements as well, but this has not been detected yet. Manao wants to determine which settlements may contain the Book. Help him with this difficult task.
Input
The first line contains three space-separated integers n, m and d (1 β€ m β€ n β€ 100000; 0 β€ d β€ n - 1). The second line contains m distinct space-separated integers p1, p2, ..., pm (1 β€ pi β€ n). Then n - 1 lines follow, each line describes a path made in the area. A path is described by a pair of space-separated integers ai and bi representing the ends of this path.
Output
Print a single number β the number of settlements that may contain the Book of Evil. It is possible that Manao received some controversial information and there is no settlement that may contain the Book. In such case, print 0.
Examples
Input
6 2 3
1 2
1 5
2 3
3 4
4 5
5 6
Output
3
Note
Sample 1. The damage range of the Book of Evil equals 3 and its effects have been noticed in settlements 1 and 2. Thus, it can be in settlements 3, 4 or 5.
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N(100010);
int n, m, d;
bool evil[N];
int d1[N], d2[N], up[N], fa[N];
vector<int> g[N];
void dp(int x) {
for (int i = int(0); i < int(g[x].size()); ++i)
if (g[x][i] != fa[x]) {
fa[g[x][i]] = x;
dp(g[x][i]);
if (d1[x] < d1[g[x][i]]) {
d2[x] = d1[x];
d1[x] = d1[g[x][i]];
} else
d2[x] = max(d2[x], d1[g[x][i]]);
}
if (d1[x] != -1) ++d1[x];
if (d2[x] != -1) ++d2[x];
if (!evil[x]) return;
if (d1[x] < 0) {
d2[x] = d1[x];
d1[x] = 0;
} else
d2[x] = max(d2[x], 0);
}
void dp2(int x) {
if (evil[x]) up[x] = max(up[x], 0);
for (int i = int(0); i < int(g[x].size()); ++i)
if (g[x][i] != fa[x]) {
int tmp = up[x], y = g[x][i];
if (d1[y] == -1 || d1[x] != d1[y] + 1)
tmp = max(tmp, d1[x]);
else
tmp = max(tmp, d2[x]);
if (tmp != -1) ++tmp;
up[g[x][i]] = tmp;
dp2(g[x][i]);
}
}
int main() {
cin >> n >> m >> d;
memset(d1, -1, sizeof(d1));
memset(d2, -1, sizeof(d2));
memset(up, -1, sizeof(up));
for (int i = int(0); i < int(m); ++i) {
int p;
scanf("%d", &p);
evil[p] = true;
}
for (int i = int(1); i < int(n); ++i) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
dp(1);
dp2(1);
int ans = 0;
for (int i = int(1); i < int(n + 1); ++i)
if (max(up[i], d1[i]) <= d) ++ans;
cout << ans << endl;
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
The Happy Farm 5 creators decided to invent the mechanism of cow grazing. The cows in the game are very slow and they move very slowly, it can even be considered that they stand still. However, carnivores should always be chased off them.
For that a young player Vasya decided to make the shepherd run round the cows along one and the same closed path. It is very important that the cows stayed strictly inside the area limited by the path, as otherwise some cows will sooner or later be eaten. To be absolutely sure in the cows' safety, Vasya wants the path completion time to be minimum.
The new game is launched for different devices, including mobile phones. That's why the developers decided to quit using the arithmetics with the floating decimal point and use only the arithmetics of integers. The cows and the shepherd in the game are represented as points on the plane with integer coordinates. The playing time is modeled by the turns. During every turn the shepherd can either stay where he stands or step in one of eight directions: horizontally, vertically, or diagonally. As the coordinates should always remain integer, then the length of a horizontal and vertical step is equal to 1, and the length of a diagonal step is equal to <image>. The cows do not move. You have to minimize the number of moves the shepherd needs to run round the whole herd.
Input
The first line contains an integer N which represents the number of cows in the herd (1 β€ N β€ 105). Each of the next N lines contains two integers Xi and Yi which represent the coordinates of one cow of (|Xi|, |Yi| β€ 106). Several cows can stand on one point.
Output
Print the single number β the minimum number of moves in the sought path.
Examples
Input
4
1 1
5 1
5 3
1 3
Output
16
Note
Picture for the example test: The coordinate grid is painted grey, the coordinates axes are painted black, the cows are painted red and the sought route is painted green.
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct vec {
long long x, y;
vec() {}
vec(long long x, long long y) : x(x), y(y) {}
bool operator<(vec const &b) const { return x == b.x ? y < b.y : x < b.x; }
long long operator^(vec const &b) const { return x * b.y - y * b.x; }
vec operator-(vec const &b) const { return vec(x - b.x, y - b.y); }
};
void convexHull(vec p[], int N, vec s[], int &m) {
sort(p, p + N);
m = 0;
for (int i = 0; i < N; i++) {
while ((m > 1) && ((p[i] - s[m]) ^ (s[m - 1] - s[m])) <= 0) m--;
s[++m] = p[i];
}
for (int i = N - 2; i >= 0; i--) {
while (((p[i] - s[m]) ^ (s[m - 1] - s[m])) <= 0) m--;
s[++m] = p[i];
}
}
vec p[(int)4e5 + 1], s[(int)4e5 + 1];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int x, y;
scanf("%d %d", &x, &y);
p[i * 4] = vec(x + 1, y);
p[i * 4 + 1] = vec(x - 1, y);
p[i * 4 + 2] = vec(x, y + 1);
p[i * 4 + 3] = vec(x, y - 1);
}
int m;
convexHull(p, 4 * n, s, m);
long long ans = 0;
for (int i = 2; i <= m; i++)
ans += max(abs(s[i].x - s[i - 1].x), abs(s[i].y - s[i - 1].y));
cout << ans << "\n";
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
Jamie is preparing a Codeforces round. He has got an idea for a problem, but does not know how to solve it. Help him write a solution to the following problem:
Find k integers such that the sum of two to the power of each number equals to the number n and the largest integer in the answer is as small as possible. As there may be multiple answers, you are asked to output the lexicographically largest one.
To be more clear, consider all integer sequence with length k (a1, a2, ..., ak) with <image>. Give a value <image> to each sequence. Among all sequence(s) that have the minimum y value, output the one that is the lexicographically largest.
For definitions of powers and lexicographical order see notes.
Input
The first line consists of two integers n and k (1 β€ n β€ 1018, 1 β€ k β€ 105) β the required sum and the length of the sequence.
Output
Output "No" (without quotes) in a single line if there does not exist such sequence. Otherwise, output "Yes" (without quotes) in the first line, and k numbers separated by space in the second line β the required sequence.
It is guaranteed that the integers in the answer sequence fit the range [ - 1018, 1018].
Examples
Input
23 5
Output
Yes
3 3 2 1 0
Input
13 2
Output
No
Input
1 2
Output
Yes
-1 -1
Note
Sample 1:
23 + 23 + 22 + 21 + 20 = 8 + 8 + 4 + 2 + 1 = 23
Answers like (3, 3, 2, 0, 1) or (0, 1, 2, 3, 3) are not lexicographically largest.
Answers like (4, 1, 1, 1, 0) do not have the minimum y value.
Sample 2:
It can be shown there does not exist a sequence with length 2.
Sample 3:
<image>
Powers of 2:
If x > 0, then 2x = 2Β·2Β·2Β·...Β·2 (x times).
If x = 0, then 2x = 1.
If x < 0, then <image>.
Lexicographical order:
Given two different sequences of the same length, (a1, a2, ... , ak) and (b1, b2, ... , bk), the first one is smaller than the second one for the lexicographical order, if and only if ai < bi, for the first i where ai and bi differ.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void calc1(int rest, int cur, int rk) {
long long invlarge = 1;
invlarge <<= (-cur);
long long q = rest * invlarge;
if (q == rk) {
for (int i = 0; i < q; i++) cout << cur << " ";
cout << endl;
return;
}
for (int i = 1; i < q; i++) cout << cur << " ";
for (int i = q; i < rk; i++) {
cur--;
cout << cur << " ";
}
cout << cur << endl;
}
void calc0(long long rest, int cur, int rk) {
if (rk == 0) {
cout << endl;
return;
}
if (cur <= 0) {
calc1(rest, cur, rk);
return;
}
long long large = 1;
large <<= cur;
long long q = rest / large, r = rest % large;
for (int i = 0; i < q - 1; i++) cout << cur << " ";
if (r > 0 || rk == q) {
if (q > 0) cout << cur << " ";
calc0(r, cur - 1, rk - q);
} else
calc0(large, cur - 1, rk - q + 1);
}
int main() {
ios::sync_with_stdio(false);
long long n;
int k;
cin >> n >> k;
long long tmp = n;
int num1 = 0;
while (tmp > 0) {
if (tmp & 1) num1++;
tmp >>= 1;
}
if (num1 > k) {
cout << "No" << endl;
return 0;
}
cout << "Yes" << endl;
double lf = log((double)n / k) / log(2);
int le = (int)lf, ri = log(n) / log(2);
if (lf > (1e-8) + le) le++;
if (le <= 0) {
calc1(n, le, k);
return 0;
}
int f, q;
long long large, r;
for (f = le; f <= ri; f++) {
large = 1;
large <<= f;
q = n / large;
r = n % large, tmp = r;
num1 = 0;
while (tmp > 0) {
if (tmp & 1) num1++;
tmp >>= 1;
}
if (num1 <= k - q) break;
}
calc0(n, f, k);
}
``` |
### Prompt
Generate a CPP solution to the following problem:
The new ITone 6 has been released recently and George got really keen to buy it. Unfortunately, he didn't have enough money, so George was going to work as a programmer. Now he faced the following problem at the work.
Given a sequence of n integers p1, p2, ..., pn. You are to choose k pairs of integers:
[l1, r1], [l2, r2], ..., [lk, rk] (1 β€ l1 β€ r1 < l2 β€ r2 < ... < lk β€ rk β€ n; ri - li + 1 = m),
in such a way that the value of sum <image> is maximal possible. Help George to cope with the task.
Input
The first line contains three integers n, m and k (1 β€ (m Γ k) β€ n β€ 5000). The second line contains n integers p1, p2, ..., pn (0 β€ pi β€ 109).
Output
Print an integer in a single line β the maximum possible value of sum.
Examples
Input
5 2 1
1 2 3 4 5
Output
9
Input
7 1 3
2 10 7 18 5 33 0
Output
61
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long inp[5010], dp[5010][5010], sumtotal[5010], srange[5010];
int main(int argc, char const *argv[]) {
int n, m, k;
cin >> n >> m >> k;
sumtotal[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> inp[i];
sumtotal[i] += sumtotal[i - 1] + inp[i];
}
for (int i = m; i <= n; i++) {
srange[i] = sumtotal[i] - sumtotal[i - m];
}
for (int i = 1; i <= k; i++) {
for (int j = m; j <= n; j++) {
dp[j][i] = max(dp[j - m][i - 1] + srange[j], dp[j - 1][i]);
}
}
cout << dp[n][k] << endl;
return 0;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
There is a grid with H rows and W columns, where each square is painted black or white.
You are given H strings S_1, S_2, ..., S_H, each of length W. If the square at the i-th row from the top and the j-th column from the left is painted black, the j-th character in the string S_i is `#`; if that square is painted white, the j-th character in the string S_i is `.`.
Find the number of pairs of a black square c_1 and a white square c_2 that satisfy the following condition:
* There is a path from the square c_1 to the square c_2 where we repeatedly move to a vertically or horizontally adjacent square through an alternating sequence of black and white squares: black, white, black, white...
Constraints
* 1 \leq H, W \leq 400
* |S_i| = W (1 \leq i \leq H)
* For each i (1 \leq i \leq H), the string S_i consists of characters `#` and `.`.
Input
Input is given from Standard Input in the following format:
H W
S_1
S_2
:
S_H
Output
Print the answer.
Examples
Input
3 3
.#.
..#
#..
Output
10
Input
3 3
.#.
..#
..
Output
10
Input
2 4
....
....
Output
0
Input
4 3
...
Output
6
### Response
```cpp
#include<bits/stdc++.h>
using ll = long long;
#define int ll
#define rep(i,n) for(int i=0;i<n;i++)
#define all(in) in.begin(), in.end()
using namespace std;
int W,H;
int dx[]={0,0,1,-1}, dy[]={1,-1,0,0};
bool valid(int x,int y){return (0<=x&&x<W)&&(0<=y&&y<H);}
vector<string>g;
vector<vector<bool>>used;
int cnt = 0;
int dfs(int y,int x){
used[y][x] = true;
char c = g[y][x];
if(c == '#')cnt++;
int cal = (c == '.');
rep(k,4){
int ny = y + dy[k];
int nx = x + dx[k];
if(valid(nx, ny) and c != g[ny][nx] and !used[ny][nx]){
cal += dfs(ny,nx);
}
}
return cal;
}
signed main(){
cin >> H >> W;
g = vector<string>(H);
used = vector<vector<bool>>(H,vector<bool>(W,false));
for(auto & s :g) cin >> s;
int ans = 0;
rep(i,H)rep(j,W)if(g[i][j] == '#' and !used[i][j]){
ans += dfs(i,j) * cnt;
cnt = 0;
}
cout << ans << endl;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
Kenkoooo found a simple connected graph. The vertices are numbered 1 through n. The i-th edge connects Vertex u_i and v_i, and has a fixed integer s_i.
Kenkoooo is trying to write a positive integer in each vertex so that the following condition is satisfied:
* For every edge i, the sum of the positive integers written in Vertex u_i and v_i is equal to s_i.
Find the number of such ways to write positive integers in the vertices.
Constraints
* 2 \leq n \leq 10^5
* 1 \leq m \leq 10^5
* 1 \leq u_i < v_i \leq n
* 2 \leq s_i \leq 10^9
* If i\neq j, then u_i \neq u_j or v_i \neq v_j.
* The graph is connected.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
n m
u_1 v_1 s_1
:
u_m v_m s_m
Output
Print the number of ways to write positive integers in the vertices so that the condition is satisfied.
Examples
Input
3 3
1 2 3
2 3 5
1 3 4
Output
1
Input
4 3
1 2 6
2 3 7
3 4 5
Output
3
Input
8 7
1 2 1000000000
2 3 2
3 4 1000000000
4 5 2
5 6 1000000000
6 7 2
7 8 1000000000
Output
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using i64 = long long;
#define rep(i,s,e) for(int (i) = (s);(i) <= (e);(i)++)
#define all(x) x.begin(),x.end()
int N,M;
struct edge{
int to;
i64 s;
};
vector<edge> G[101010];
int main(){
cin >> N >> M;
rep(i,0,M - 1){
int u,v;
i64 s;
cin >> u >> v;
cin >> s;
G[u].push_back({v,s});
G[v].push_back({u,s});
}
queue<int> que;
que.push(1);
vector<i64> op(101010,0);
vector<i64> C(101010,0);
i64 bottom = 0;
i64 up = 1e18;
i64 A;
bool defined = false;
op[1] = 1;
while(!que.empty()){
int v = que.front();
que.pop();
for(auto e : G[v]){
if(op[e.to] == 0){
op[e.to] = op[v] * -1;
C[e.to] = e.s - C[v];
if(op[e.to] == 1){
bottom = max(bottom , -C[e.to]);
}
else{
up = min(up , C[e.to]);
}
que.push(e.to);
}
else if(op[e.to] == op[v]){
i64 c = C[e.to] + C[v];
if(abs(e.s - c) % 2 == 1){
cout << 0 << endl;
return 0;
}
i64 a = op[v] * (e.s - c) / 2;
if(a <= 0){
cout << 0 << endl;
return 0;
}
if(!defined){
A = a;
defined = true;
}
else if(A != a){
cout << 0 << endl;
return 0;
}
}
else if(C[e.to] + C[v] != e.s){
cout << 0 << endl;
return 0;
}
}
}
if(defined){
cout << ((bottom < A) && (A < up)) << endl;
}
else{
cout << max(0LL,up - bottom - 1) << endl;
}
}
``` |
### Prompt
Create a solution in CPP for the following problem:
D: Sontaku (Surmise)
Some twins like even numbers.
Count how many even numbers are in $ N $ integers $ A_1, A_2, A_3, \ dots, A_N $.
input
The integer $ N $ is given on the first line.
On the second line, $ N $ integers $ A_1, A_2, A_3, \ dots, A_N $ are given, separated by blanks.
output
Output an even number. However, insert a line break at the end.
Constraint
* $ N $ is an integer greater than or equal to $ 1 $ and less than or equal to $ 100 $
* $ A_1, A_2, A_3, \ dots, A_N $ are integers between $ 1 $ and $ 100 $
Input example 1
Five
4 3 5 2 6
Output example 1
3
$ A_1 = 4 $, $ A_4 = 2 $ and $ A_5 = 6 $ are even numbers. Therefore, the even number is $ 3 $.
Input example 2
3
2 2 2
Output example 2
3
Even if the numbers are the same, if the positions in $ A_1, A_2, A_3, \ dots, A_N $ are different, they are counted as different numbers.
Example
Input
5
4 3 5 2 6
Output
3
### Response
```cpp
#include <cstdio>
#include <string>
#include <algorithm>
using namespace std;
int main() {
int n, t, sum = 0;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &t);
if (!(t & 1)) sum++;
}
printf("%d\n", sum);
return 0;
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
Fox Ciel starts to learn programming. The first task is drawing a fox! However, that turns out to be too hard for a beginner, so she decides to draw a snake instead.
A snake is a pattern on a n by m table. Denote c-th cell of r-th row as (r, c). The tail of the snake is located at (1, 1), then it's body extends to (1, m), then goes down 2 rows to (3, m), then goes left to (3, 1) and so on.
Your task is to draw this snake for Fox Ciel: the empty cells should be represented as dot characters ('.') and the snake cells should be filled with number signs ('#').
Consider sample tests in order to understand the snake pattern.
Input
The only line contains two integers: n and m (3 β€ n, m β€ 50).
n is an odd number.
Output
Output n lines. Each line should contain a string consisting of m characters. Do not output spaces.
Examples
Input
3 3
Output
###
..#
###
Input
3 4
Output
####
...#
####
Input
5 3
Output
###
..#
###
#..
###
Input
9 9
Output
#########
........#
#########
#........
#########
........#
#########
#........
#########
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int m, n;
cin >> m >> n;
for (int i = 1; i < m + 1; i++) {
if (i % 2 == 1) {
for (int j = 0; j < n; j++) cout << "#";
cout << endl;
} else if ((i + 2) % 4 == 0) {
for (int j = 0; j < n - 1; j++) cout << ".";
cout << "#" << endl;
} else {
cout << "#";
for (int j = 0; j < n - 1; j++) cout << ".";
cout << endl;
}
}
return 0;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
You must have heard of the two brothers dreaming of ruling the world. With all their previous plans failed, this time they decided to cooperate with each other in order to rule the world.
As you know there are n countries in the world. These countries are connected by n - 1 directed roads. If you don't consider direction of the roads there is a unique path between every pair of countries in the world, passing through each road at most once.
Each of the brothers wants to establish his reign in some country, then it's possible for him to control the countries that can be reached from his country using directed roads.
The brothers can rule the world if there exists at most two countries for brothers to choose (and establish their reign in these countries) so that any other country is under control of at least one of them. In order to make this possible they want to change the direction of minimum number of roads. Your task is to calculate this minimum number of roads.
Input
The first line of input contains an integer n (1 β€ n β€ 3000). Each of the next n - 1 lines contains two space-separated integers ai and bi (1 β€ ai, bi β€ n; ai β bi) saying there is a road from country ai to country bi.
Consider that countries are numbered from 1 to n. It's guaranteed that if you don't consider direction of the roads there is a unique path between every pair of countries in the world, passing through each road at most once.
Output
In the only line of output print the minimum number of roads that their direction should be changed so that the brothers will be able to rule the world.
Examples
Input
4
2 1
3 1
4 1
Output
1
Input
5
2 1
2 3
4 3
4 5
Output
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3000 + 2;
vector<int> v[maxn], v_[maxn];
int n;
int dp[maxn][2];
int vis[maxn];
int par[maxn];
inline pair<int, int> DFS(int st) {
vis[st] = 1;
dp[st][0] = dp[st][1] = 0;
for (int i = 0; i < v[st].size(); ++i)
if (vis[v[st][i]] == 0) {
pair<int, int> hlp = DFS(v[st][i]);
dp[st][0] += hlp.first;
dp[st][1] = min(dp[st][1], 1 + hlp.second - hlp.first);
}
for (int i = 0; i < v_[st].size(); ++i)
if (vis[v_[st][i]] == 0) {
par[v_[st][i]] = 1;
pair<int, int> hlp = DFS(v_[st][i]);
dp[st][0] += hlp.first + 1;
dp[st][1] = min(dp[st][1], -1 + hlp.second - hlp.first);
}
dp[st][1] += dp[st][0];
return pair<int, int>(dp[st][0], dp[st][1]);
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n - 1; ++i) {
int v1, v2;
cin >> v1 >> v2;
v[v1].push_back(v2);
v_[v2].push_back(v1);
}
int ans = 100000;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) vis[j] = 0;
for (int j = 1; j <= n; ++j) par[j] = 0;
DFS(i);
ans = min(ans, dp[i][0]);
for (int j = 1; j <= n; ++j)
if (i != j) ans = min(ans, dp[i][0] - dp[j][0] + dp[j][1] - par[j]);
}
cout << ans << endl;
return 0;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
problem
Taro often shop at JOI general stores. At JOI general stores, there are enough coins of 500 yen, 100 yen, 50 yen, 10 yen, 5 yen, and 1 yen, and we always pay the change so that the number of coins is the smallest. Create a program to find the number of coins included in the change you receive when Taro goes shopping at the JOI general store and puts out one 1000 yen bill at the cash register.
For example, in the case of input example 1, 4 must be output as shown in the figure below.
<image>
input
The input consists of multiple datasets. Each dataset consists of one line, and only one amount (an integer of 1 or more and less than 1000) paid by Taro is written. The input data ends with one zero line.
The number of datasets does not exceed 5.
output
Output the number of coins included in the change for each dataset on one line.
Examples
Input
380
1
0
Output
4
15
Input
None
Output
None
### Response
```cpp
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n;
while(cin>>n){
if(n==0) break;
n=1000-n;
int ans=0;
ans=ans+n/500;
n=n%500;
ans=ans+n/100;
n=n%100;
ans=ans+n/50;
n=n%50;
ans=ans+n/10;
n=n%10;
ans=ans+n/5;
n=n%5;
ans=ans+n;
cout<<ans<<endl;
}
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
Dima liked the present he got from Inna very much. He liked the present he got from Seryozha even more.
Dima felt so grateful to Inna about the present that he decided to buy her n hares. Inna was very happy. She lined up the hares in a row, numbered them from 1 to n from left to right and started feeding them with carrots. Inna was determined to feed each hare exactly once. But in what order should she feed them?
Inna noticed that each hare radiates joy when she feeds it. And the joy of the specific hare depends on whether Inna fed its adjacent hares before feeding it. Inna knows how much joy a hare radiates if it eats when either both of his adjacent hares are hungry, or one of the adjacent hares is full (that is, has been fed), or both of the adjacent hares are full. Please note that hares number 1 and n don't have a left and a right-adjacent hare correspondingly, so they can never have two full adjacent hares.
Help Inna maximize the total joy the hares radiate. :)
Input
The first line of the input contains integer n (1 β€ n β€ 3000) β the number of hares. Then three lines follow, each line has n integers. The first line contains integers a1 a2 ... an. The second line contains b1, b2, ..., bn. The third line contains c1, c2, ..., cn. The following limits are fulfilled: 0 β€ ai, bi, ci β€ 105.
Number ai in the first line shows the joy that hare number i gets if his adjacent hares are both hungry. Number bi in the second line shows the joy that hare number i radiates if he has exactly one full adjacent hare. Number Ρi in the third line shows the joy that hare number i radiates if both his adjacent hares are full.
Output
In a single line, print the maximum possible total joy of the hares Inna can get by feeding them.
Examples
Input
4
1 2 3 4
4 3 2 1
0 1 1 0
Output
13
Input
7
8 5 7 6 1 8 9
2 7 9 5 4 3 1
2 3 3 4 1 1 3
Output
44
Input
3
1 1 1
1 2 1
1 1 1
Output
4
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct z {
int zero;
int one;
int two;
};
z za[3010];
int d0[3010];
int d1[3010];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> za[i].zero;
}
for (int i = 1; i <= n; i++) {
cin >> za[i].one;
}
for (int i = 1; i <= n; i++) {
cin >> za[i].two;
}
d0[1] = za[1].zero;
d1[1] = za[1].one;
for (int i = 2; i <= n; i++) {
d0[i] = max(d0[i - 1] + za[i].one, d1[i - 1] + za[i].zero);
d1[i] = max(d0[i - 1] + za[i].two, d1[i - 1] + za[i].one);
}
cout << d0[n] << endl;
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
As meticulous Gerald sets the table, Alexander finished another post on Codeforces and begins to respond to New Year greetings from friends. Alexander has n friends, and each of them sends to Alexander exactly one e-card. Let us number his friends by numbers from 1 to n in the order in which they send the cards. Let's introduce the same numbering for the cards, that is, according to the numbering the i-th friend sent to Alexander a card number i.
Alexander also sends cards to friends, but he doesn't look for the new cards on the Net. He simply uses the cards previously sent to him (sometimes, however, he does need to add some crucial details). Initially Alexander doesn't have any cards. Alexander always follows the two rules:
1. He will never send to a firend a card that this friend has sent to him.
2. Among the other cards available to him at the moment, Alexander always chooses one that Alexander himself likes most.
Alexander plans to send to each friend exactly one card. Of course, Alexander can send the same card multiple times.
Alexander and each his friend has the list of preferences, which is a permutation of integers from 1 to n. The first number in the list is the number of the favorite card, the second number shows the second favorite, and so on, the last number shows the least favorite card.
Your task is to find a schedule of sending cards for Alexander. Determine at which moments of time Alexander must send cards to his friends, to please each of them as much as possible. In other words, so that as a result of applying two Alexander's rules, each friend receives the card that is preferred for him as much as possible.
Note that Alexander doesn't choose freely what card to send, but he always strictly follows the two rules.
Input
The first line contains an integer n (2 β€ n β€ 300) β the number of Alexander's friends, equal to the number of cards. Next n lines contain his friends' preference lists. Each list consists of n different integers from 1 to n. The last line contains Alexander's preference list in the same format.
Output
Print n space-separated numbers: the i-th number should be the number of the friend, whose card Alexander receives right before he should send a card to the i-th friend. If there are several solutions, print any of them.
Examples
Input
4
1 2 3 4
4 1 3 2
4 3 1 2
3 4 2 1
3 1 2 4
Output
2 1 1 4
Note
In the sample, the algorithm of actions Alexander and his friends perform is as follows:
1. Alexander receives card 1 from the first friend.
2. Alexander sends the card he has received (at the moment he only has one card, and therefore it is the most preferable for him) to friends with the numbers 2 and 3.
3. Alexander receives card 2 from the second friend, now he has two cards β 1 and 2.
4. Alexander sends a card to the first friend. Despite the fact that Alexander likes card 1 more, he sends card 2 as he cannot send a friend the card sent by that very friend.
5. Alexander receives card 3 from the third friend.
6. Alexander receives card 4 from the fourth friend.
7. Among the cards Alexander has number 3 is his favorite and he sends it to the fourth friend.
Note that Alexander can send cards to multiple friends at a time (in this case the second and the third one). Alexander can send card 3 to the fourth friend after he receives the third card or after he receives the fourth card (both variants are correct).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int prep[300][300];
int my_prev[300];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) scanf("%d", &prep[i][j]);
for (int i = 0; i < n; i++) scanf("%d", &my_prev[i]);
int my_prev_pos[301] = {0};
for (int i = 0; i < n; i++) my_prev_pos[my_prev[i]] = i;
int res[300] = {0};
for (int i = 0; i < n; i++) {
int opp_pos[301] = {0};
for (int j = 0; j < n; j++) opp_pos[prep[i][j]] = j;
int best_pos = 999;
int best_num = 999;
int opp_best_pos = 999;
int opp_best_num = 999;
for (int j = 1; j <= n; j++) {
if (i + 1 == j) continue;
if (my_prev_pos[j] < best_pos) {
best_pos = my_prev_pos[j];
best_num = j;
if (opp_pos[best_num] < opp_best_pos) {
opp_best_pos = opp_pos[best_num];
opp_best_num = best_num;
}
}
}
res[i] = opp_best_num;
}
for (int i = 0; i < n; i++) printf("%d ", res[i]);
printf("\n");
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
You are given an array a of n integers. Define the cost of some array t as follows:
$$$cost(t) = β_{x β set(t) } last(x) - first(x),$$$
where set(t) is the set of all values in t without repetitions, first(x), and last(x) are the indices of the first and last occurrence of x in t, respectively. In other words, we compute the distance between the first and last occurrences for each distinct element and sum them up.
You need to split the array a into k consecutive segments such that each element of a belongs to exactly one segment and the sum of the cost of individual segments is minimum.
Input
The first line contains two integers n, k (1 β€ n β€ 35 000, 1 β€ k β€ min(n,100)).
The second line contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ n).
Output
Output the minimum sum of the cost of individual segments.
Examples
Input
7 2
1 6 6 4 6 6 6
Output
3
Input
7 4
5 5 5 5 2 3 3
Output
1
Note
In the first example, we can divide the array into [1,6,6,4] and [6,6,6]. Cost of [1,6,6,4] will be (1-1) + (3 - 2) + (4-4) = 1 and cost of [6,6,6] will be 3-1 = 2. Total cost would be 1 + 2 = 3.
In the second example, divide the array into [5,5],[5],[5,2,3] and [3]. Total Cost would be 1 + 0 + 0 + 0 = 1.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
#define ll long long
const int N = 35005;
const int K = 101;
int a[N];
int dp[K][N];
int color[N],d[N];
int cut_value[N];
int get_cost(int l,int r) {
assert(l<=r);
return dp[1][r] - dp[1][l-1] - cut_value[l];
}
void dnc(int k,int l,int r,int x,int y) {
if(l>r) return;
int mid = x+y>>1;
int v;
for(int i=min(y,mid);i>=x;--i) {
//
}
dnc(k,l,mid,x,v),
dnc(k,mid+1,r,v,y);
}
int seg[N*4],lazy[N*4];
void init(int k,int pos,int l,int r) {
lazy[pos] = 0;
if(l==r) {
seg[pos] = dp[k-1][l];
return;
}
int mid = l+r>>1;
init(k,pos*2,l,mid),
init(k,pos*2+1,mid+1,r);
seg[pos] = min(seg[pos*2],seg[pos*2+1]);
}
void push(int pos,int l,int r) {
if(lazy[pos]!=0) {
seg[pos] += lazy[pos];
if(l!=r) {
lazy[pos*2] += lazy[pos];
lazy[pos*2+1] += lazy[pos];
}
lazy[pos] = 0;
}
}
void update(int pos,int l,int r,int ql,int qr,int val) {
push(pos,l,r);
if(r<ql || qr<l) {
return;
}
if(ql<=l && r<=qr) {
lazy[pos] = val;
push(pos,l,r);
return;
}
int mid = (l+r)/2;
update(pos*2,l,mid,ql,qr,val);
update(pos*2+1,mid+1,r,ql,qr,val);
seg[pos] = min(seg[pos*2],seg[pos*2+1]);
}
int query(int pos,int l,int r,int ql,int qr) {
push(pos,l,r);
if(r<ql || qr<l) {
return 1e9;
}
if(ql<=l && r<=qr) {
return seg[pos];
}
int mid = (l+r)/2;
return min(query(pos*2,l,mid,ql,qr),query(pos*2+1,mid+1,r,ql,qr));
}
void solve2() {
int n,k;
scanf("%d %d ", &n,&k);
for(int i=1;i<=n;++i) {
scanf("%d ", &a[i]);
}
int value = 0;
for(int i=1;i<=n;++i) {
if(color[a[i]]) {
value += i - color[a[i]];
}
color[a[i]] = i;
dp[1][i] = value;
}
for(int i=k;i;--i) dp[i][0] = 1e9;
for(int i=2;i<=k;++i) {
init(i,1,0,n);
for(int j=1;j<=n;++j) color[j] = 0;
for(int j=1;j<=n;++j) {
if(color[a[j]]) {
update(1,0,n,0,color[a[j]]-1, j-color[a[j]]);
}
color[a[j]] = j;
dp[i][j] = query(1,0,n,0,j-1);
}
}
printf("%d\n", dp[k][n]);
}
void solve() {
// int t;
// scanf("%d",&t);
// while(t--)
solve2();
}
inline bool exists_test0 (const std::string& name);
inline bool exists_test1 (const std::string& name);
int main() {
#ifdef LOCAL
string file_name = "input.txt";
assert(exists_test0(file_name));
assert(exists_test1(file_name));
freopen("input.txt","r",stdin);
#endif
solve();
return 0;
}
/*
0. Enough array size? Enough array size? Integer overflow?
1. Think TWICE, Code ONCE!
Are there any counterexamples to your algo?
2. Be careful about the BOUNDARIES!
N=1? P=1? Something about 0?
3. Do not make STUPID MISTAKES!
Time complexity? Memory usage? Precision error?
4. Be careful to use wrong variable.
*/
inline bool exists_test0 (const std::string& name) {
ifstream f(name.c_str());
return f.good();
}
inline bool exists_test1 (const std::string& name) {
if (FILE *file = fopen(name.c_str(), "r")) {
fclose(file);
return true;
} else {
return false;
}
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
We have N points in a two-dimensional plane.
The coordinates of the i-th point (1 \leq i \leq N) are (x_i,y_i).
Let us consider a rectangle whose sides are parallel to the coordinate axes that contains K or more of the N points in its interior.
Here, points on the sides of the rectangle are considered to be in the interior.
Find the minimum possible area of such a rectangle.
Constraints
* 2 \leq K \leq N \leq 50
* -10^9 \leq x_i,y_i \leq 10^9 (1 \leq i \leq N)
* x_iβ x_j (1 \leq i<j \leq N)
* y_iβ y_j (1 \leq i<j \leq N)
* All input values are integers. (Added at 21:50 JST)
Input
Input is given from Standard Input in the following format:
N K
x_1 y_1
:
x_{N} y_{N}
Output
Print the minimum possible area of a rectangle that satisfies the condition.
Examples
Input
4 4
1 4
3 3
6 2
8 1
Output
21
Input
4 2
0 0
1 1
2 2
3 3
Output
1
Input
4 3
-1000000000 -1000000000
1000000000 1000000000
-999999999 999999999
999999999 -999999999
Output
3999999996000000001
### Response
```cpp
#include <bits/stdc++.h>
#define rep(i,n) for (int i=0; i<(n); ++i)
using namespace std;
using ll = long long;
using P = pair<int,int>;
int main(){
int n,k;
cin>>n>>k;
vector<int>x(n),y(n);
rep(i,n)cin>>x[i]>>y[i];
ll ans=LONG_LONG_MAX;
rep(a,n)rep(b,n)rep(c,n)rep(d,n){
int L=x[a],R=x[b],D=y[c],U=y[d];
if(R<L||U<D)continue;
int cnt=0;
rep(v,n){
if(L<=x[v]&&x[v]<=R&&D<=y[v]&&y[v]<=U)cnt++;
}
if(cnt>=k)ans=min(ans,(ll)(R-L)*(U-D));
}
cout<<ans<<endl;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
You are given two circles. Find the area of their intersection.
Input
The first line contains three integers x1, y1, r1 ( - 109 β€ x1, y1 β€ 109, 1 β€ r1 β€ 109) β the position of the center and the radius of the first circle.
The second line contains three integers x2, y2, r2 ( - 109 β€ x2, y2 β€ 109, 1 β€ r2 β€ 109) β the position of the center and the radius of the second circle.
Output
Print the area of the intersection of the circles. The answer will be considered correct if the absolute or relative error doesn't exceed 10 - 6.
Examples
Input
0 0 4
6 0 4
Output
7.25298806364175601379
Input
0 0 5
11 0 5
Output
0.00000000000000000000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long double r2, d, r1, s;
long double x1, yy1, a, x2, yy2;
long double tam;
void home() {}
void in() {
cin >> x1 >> yy1 >> r1 >> x2 >> yy2 >> r2;
d = sqrt((x2 - x1) * (x2 - x1) + (yy2 - yy1) * (yy2 - yy1));
if (r1 + r2 <= d) {
cout << 0;
return;
}
long double r = min(r1, r2);
long double PI = acos(-1);
if (fabs(r2 - r1) >= d) {
cout << fixed << setprecision(20) << PI * r * r;
return;
}
tam = r2 * r2 + d * d - r1 * r1;
s = 2 * r2 * d;
a = acos(tam / s);
s = a * r2 * r2;
long double z = sin(a);
long double z1 = cos(a);
long double t = r2 * r2 * z * z1;
s -= t;
tam = r1 * r1 + d * d - r2 * r2;
tam /= 2 * r1 * d;
a = acos(tam);
z = sin(a);
z1 = cos(a);
t = r1 * r1 * z * z1;
s += a * r1 * r1 - t;
cout << setprecision(20) << s;
}
int main() {
home();
in();
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Shubham has a binary string s. A binary string is a string containing only characters "0" and "1".
He can perform the following operation on the string any amount of times:
* Select an index of the string, and flip the character at that index. This means, if the character was "0", it becomes "1", and vice versa.
A string is called good if it does not contain "010" or "101" as a subsequence β for instance, "1001" contains "101" as a subsequence, hence it is not a good string, while "1000" doesn't contain neither "010" nor "101" as subsequences, so it is a good string.
What is the minimum number of operations he will have to perform, so that the string becomes good? It can be shown that with these operations we can make any string good.
A string a is a subsequence of a string b if a can be obtained from b by deletion of several (possibly, zero or all) characters.
Input
The first line of the input contains a single integer t (1β€ t β€ 100) β the number of test cases.
Each of the next t lines contains a binary string s (1 β€ |s| β€ 1000).
Output
For every string, output the minimum number of operations required to make it good.
Example
Input
7
001
100
101
010
0
1
001100
Output
0
0
1
1
0
0
2
Note
In test cases 1, 2, 5, 6 no operations are required since they are already good strings.
For the 3rd test case: "001" can be achieved by flipping the first character β and is one of the possible ways to get a good string.
For the 4th test case: "000" can be achieved by flipping the second character β and is one of the possible ways to get a good string.
For the 7th test case: "000000" can be achieved by flipping the third and fourth characters β and is one of the possible ways to get a good string.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long bin_exp(long long a, long long n) {
long long res = 1;
while (n) {
if (n & 1) res = res * a;
a = a * a;
n = n >> 1;
}
return res;
}
long long bin_exp_modulo(long long a, long long n, long long m) {
if (a == 0) return 0;
long long res = 1;
a = a % m;
while (n) {
if (n & 1) res = ((res % m) * (a % m)) % m;
a = ((a % m) * (a % m)) % m;
n = n >> 1;
}
return res % m;
}
long long gcd(long long a, long long b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
void work() {
string str;
cin >> str;
int n = str.length();
string zero = "", one = "";
int ans = 0;
for (int i = 0; i < n; ++i) {
zero = "";
one = "";
for (int j = 0; j < n; ++j) {
if (j <= i) {
zero += "0";
one += "1";
} else {
zero += "1";
one += "0";
}
}
int zz = 0, oo = 0;
for (int j = 0; j < n; ++j) {
if (str[j] != zero[j]) ++zz;
if (str[j] != one[j]) ++oo;
}
if (i == 0)
ans = min(zz, oo);
else
ans = min({ans, zz, oo});
}
cout << ans;
}
int main() {
int test;
cin >> test;
for (int i = 0; i < test; ++i) {
work();
cout << "\n";
}
return 0;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
There is a tree with N vertices numbered 1 through N. The i-th of the N-1 edges connects vertices a_i and b_i.
Initially, each edge is painted blue. Takahashi will convert this blue tree into a red tree, by performing the following operation N-1 times:
* Select a simple path that consists of only blue edges, and remove one of those edges.
* Then, span a new red edge between the two endpoints of the selected path.
His objective is to obtain a tree that has a red edge connecting vertices c_i and d_i, for each i.
Determine whether this is achievable.
Constraints
* 2 β€ N β€ 10^5
* 1 β€ a_i,b_i,c_i,d_i β€ N
* a_i β b_i
* c_i β d_i
* Both input graphs are trees.
Input
Input is given from Standard Input in the following format:
N
a_1 b_1
:
a_{N-1} b_{N-1}
c_1 d_1
:
c_{N-1} d_{N-1}
Output
Print `YES` if the objective is achievable; print `NO` otherwise.
Examples
Input
3
1 2
2 3
1 3
3 2
Output
YES
Input
5
1 2
2 3
3 4
4 5
3 4
2 4
1 4
1 5
Output
YES
Input
6
1 2
3 5
4 6
1 6
5 1
5 3
1 4
2 6
4 3
5 6
Output
NO
### Response
```cpp
#include <set>
#include <queue>
#include <cstdio>
#include <algorithm>
using namespace std;
const int N=1e5+10;
int n,f[N];
set<int>B[N],R[N];
queue< pair<int,int> >Q;
void Init()
{
scanf("%d",&n);
int a,b;
for (int i=1;i<n;++i)
{
scanf("%d%d",&a,&b);
B[a].insert(b); B[b].insert(a);
}
for (int i=1;i<n;++i)
{
scanf("%d%d",&a,&b);
R[a].insert(b); R[b].insert(a);
if (B[a].count(b)) Q.push(make_pair(a,b));
}
}
int find(int a) { return a==f[a]?a:f[a]=find(f[a]); }
void Union(int x,int y)
{
if (R[x].size()>R[y].size()) swap(x,y);
f[x]=y;
for (auto a:R[x]) if (B[a].count(y)) Q.push(make_pair(a,y));
for (auto a:B[x]) if (R[a].count(y)) Q.push(make_pair(a,y));
for (auto a:R[x]) { R[a].erase(x); R[a].insert(y); R[y].insert(a); }
for (auto a:B[x]) { B[a].erase(x); B[a].insert(y); B[y].insert(a); }
}
void Solve()
{
for (int i=1;i<=n;++i) f[i]=i;
int cnt=0;
while (!Q.empty())
{
int x=Q.front().first,y=Q.front().second; Q.pop();
x=find(x); y=find(y);
if (x==y) continue;
++cnt;
R[x].erase(y); R[y].erase(x); B[x].erase(y); B[y].erase(x);
Union(x,y);
}
if (cnt==n-1) printf("YES\n");
else printf("NO\n");
}
int main()
{
Init();
Solve();
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
There is a right triangle with legs of length a and b. Your task is to determine whether it is possible to locate the triangle on the plane in such a way that none of its sides is parallel to the coordinate axes. All the vertices must have integer coordinates. If there exists such a location, you have to output the appropriate coordinates of vertices.
Input
The first line contains two integers a, b (1 β€ a, b β€ 1000), separated by a single space.
Output
In the first line print either "YES" or "NO" (without the quotes) depending on whether the required location exists. If it does, print in the next three lines three pairs of integers β the coordinates of the triangle vertices, one pair per line. The coordinates must be integers, not exceeding 109 in their absolute value.
Examples
Input
1 1
Output
NO
Input
5 5
Output
YES
2 1
5 5
-2 4
Input
5 10
Output
YES
-10 4
-2 -2
1 2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
bool isPerfectSquare(long long int n) {
for (long long int i = 1; i * i <= n; i++) {
if ((n % i == 0) && (n / i == i)) {
return true;
}
}
return false;
}
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int a, b;
cin >> a >> b;
for (long long int i = 1; i < a; i++) {
if (isPerfectSquare(a * a - i * i)) {
long long int y = sqrt(a * a - i * i);
long long int temp = gcd(i, y);
long long int bx = -y / temp, by = i / temp;
long long int modB = sqrt(bx * bx + by * by);
if (modB && b % modB == 0) {
if (y != by * (b / modB)) {
cout << "YES\n0 0" << endl;
cout << i << " " << y << endl;
cout << bx * (b / modB) << " " << by * (b / modB) << endl;
return 0;
}
}
}
}
cout << "NO" << endl;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
The new operating system BerOS has a nice feature. It is possible to use any number of characters '/' as a delimiter in path instead of one traditional '/'. For example, strings //usr///local//nginx/sbin// and /usr/local/nginx///sbin are equivalent. The character '/' (or some sequence of such characters) at the end of the path is required only in case of the path to the root directory, which can be represented as single character '/'.
A path called normalized if it contains the smallest possible number of characters '/'.
Your task is to transform a given path to the normalized form.
Input
The first line of the input contains only lowercase Latin letters and character '/' β the path to some directory. All paths start with at least one character '/'. The length of the given line is no more than 100 characters, it is not empty.
Output
The path in normalized form.
Examples
Input
//usr///local//nginx/sbin
Output
/usr/local/nginx/sbin
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long int M = 1e9 + 7;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
string s;
cin >> s;
long long int n = s.length();
bool ok[n];
memset(ok, true, sizeof(ok));
long long int it = n - 1;
while (s[it] == '/' && it >= 1) {
ok[it] = 0;
it--;
}
for (long long int i = 0; i < s.length(); ++i) {
if (s[i] == '/') {
long long int j = i + 1;
while (s[j] == '/') {
ok[j] = 0;
j++;
}
i = j - 1;
}
}
for (long long int i = 0; i < n; ++i) {
if (ok[i]) cout << s[i];
}
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
There is an infinite sequence consisting of all positive integers in the increasing order: p = {1, 2, 3, ...}. We performed n swap operations with this sequence. A swap(a, b) is an operation of swapping the elements of the sequence on positions a and b. Your task is to find the number of inversions in the resulting sequence, i.e. the number of such index pairs (i, j), that i < j and pi > pj.
Input
The first line contains a single integer n (1 β€ n β€ 105) β the number of swap operations applied to the sequence.
Each of the next n lines contains two integers ai and bi (1 β€ ai, bi β€ 109, ai β bi) β the arguments of the swap operation.
Output
Print a single integer β the number of inversions in the resulting sequence.
Examples
Input
2
4 2
1 4
Output
4
Input
3
1 6
3 4
2 5
Output
15
Note
In the first sample the sequence is being modified as follows: <image>. It has 4 inversions formed by index pairs (1, 4), (2, 3), (2, 4) and (3, 4).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int bd = 18, bdv = 1 << bd;
int n;
map<int, int> mp;
vector<int> arrx;
int rsq[bdv * 2];
int segtree_plus(int pos) {
pos += bdv;
rsq[pos] = 1;
pos /= 2;
while (pos) {
rsq[pos] = rsq[pos * 2] + rsq[pos * 2 + 1];
pos /= 2;
}
return 0;
}
int segtree_sum(int v, int vl, int vr, int l, int r) {
if (r < vl || vr < l) {
return 0;
}
if (l <= vl && vr <= r) {
return rsq[v];
}
int vm = (vl + vr) / 2;
return segtree_sum(v * 2, vl, vm, l, r) +
segtree_sum(v * 2 + 1, vm + 1, vr, l, r);
}
int main() {
cin >> n;
for (int i = 0; i < n; ++i) {
int a, b;
cin >> a >> b;
arrx.push_back(a);
arrx.push_back(b);
if (!mp.count(a)) {
mp[a] = a;
}
if (!mp.count(b)) {
mp[b] = b;
}
int tmp = mp[a];
mp[a] = mp[b];
mp[b] = tmp;
}
sort((arrx).begin(), (arrx).end());
arrx.resize(unique((arrx).begin(), (arrx).end()) - arrx.begin());
long long ans = 0;
for (map<int, int>::iterator it = mp.begin(); it != mp.end(); ++it) {
int where = it->first;
int what = it->second;
ans += segtree_sum(
1, 0, bdv - 1,
lower_bound((arrx).begin(), (arrx).end(), what) - arrx.begin() + 1,
bdv - 1);
if (what > where) {
ans += what - where -
(upper_bound((arrx).begin(), (arrx).end(), what) -
upper_bound((arrx).begin(), (arrx).end(), where));
} else {
ans += where - what -
(upper_bound((arrx).begin(), (arrx).end(), where) -
upper_bound((arrx).begin(), (arrx).end(), what));
}
segtree_plus(lower_bound((arrx).begin(), (arrx).end(), what) -
arrx.begin());
}
cout << ans << endl;
return 0;
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
Iahub is a big fan of tourists. He wants to become a tourist himself, so he planned a trip. There are n destinations on a straight road that Iahub wants to visit. Iahub starts the excursion from kilometer 0. The n destinations are described by a non-negative integers sequence a1, a2, ..., an. The number ak represents that the kth destination is at distance ak kilometers from the starting point. No two destinations are located in the same place.
Iahub wants to visit each destination only once. Note that, crossing through a destination is not considered visiting, unless Iahub explicitly wants to visit it at that point. Also, after Iahub visits his last destination, he doesn't come back to kilometer 0, as he stops his trip at the last destination.
The distance between destination located at kilometer x and next destination, located at kilometer y, is |x - y| kilometers. We call a "route" an order of visiting the destinations. Iahub can visit destinations in any order he wants, as long as he visits all n destinations and he doesn't visit a destination more than once.
Iahub starts writing out on a paper all possible routes and for each of them, he notes the total distance he would walk. He's interested in the average number of kilometers he would walk by choosing a route. As he got bored of writing out all the routes, he asks you to help him.
Input
The first line contains integer n (2 β€ n β€ 105). Next line contains n distinct integers a1, a2, ..., an (1 β€ ai β€ 107).
Output
Output two integers β the numerator and denominator of a fraction which is equal to the wanted average number. The fraction must be irreducible.
Examples
Input
3
2 3 5
Output
22 3
Note
Consider 6 possible routes:
* [2, 3, 5]: total distance traveled: |2 β 0| + |3 β 2| + |5 β 3| = 5;
* [2, 5, 3]: |2 β 0| + |5 β 2| + |3 β 5| = 7;
* [3, 2, 5]: |3 β 0| + |2 β 3| + |5 β 2| = 7;
* [3, 5, 2]: |3 β 0| + |5 β 3| + |2 β 5| = 8;
* [5, 2, 3]: |5 β 0| + |2 β 5| + |3 β 2| = 9;
* [5, 3, 2]: |5 β 0| + |3 β 5| + |2 β 3| = 8.
The average travel distance is <image> = <image> = <image>.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long int gcdof(long long int a, long long int b) {
if (a == 0) return b;
return gcdof(b % a, a);
}
int main() {
int n, i;
cin >> n;
long long int a[n];
long long int num = 0, sum = 0, gcd;
for (i = 0; i < n; i++) {
cin >> a[i];
sum = sum + a[i];
}
sort(a, a + n);
num = num + sum;
for (i = 0; i < n - 1; i++) {
sum = sum - a[i];
num = num + 2 * (sum - ((n - (i + 1)) * a[i]));
}
gcd = gcdof(n, num);
num = num / gcd;
n = n / gcd;
cout << num << " " << n << endl;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
The map of the capital of Berland can be viewed on the infinite coordinate plane. Each point with integer coordinates contains a building, and there are streets connecting every building to four neighbouring buildings. All streets are parallel to the coordinate axes.
The main school of the capital is located in (s_x, s_y). There are n students attending this school, the i-th of them lives in the house located in (x_i, y_i). It is possible that some students live in the same house, but no student lives in (s_x, s_y).
After classes end, each student walks from the school to his house along one of the shortest paths. So the distance the i-th student goes from the school to his house is |s_x - x_i| + |s_y - y_i|.
The Provision Department of Berland has decided to open a shawarma tent somewhere in the capital (at some point with integer coordinates). It is considered that the i-th student will buy a shawarma if at least one of the shortest paths from the school to the i-th student's house goes through the point where the shawarma tent is located. It is forbidden to place the shawarma tent at the point where the school is located, but the coordinates of the shawarma tent may coincide with the coordinates of the house of some student (or even multiple students).
You want to find the maximum possible number of students buying shawarma and the optimal location for the tent itself.
Input
The first line contains three integers n, s_x, s_y (1 β€ n β€ 200 000, 0 β€ s_x, s_y β€ 10^{9}) β the number of students and the coordinates of the school, respectively.
Then n lines follow. The i-th of them contains two integers x_i, y_i (0 β€ x_i, y_i β€ 10^{9}) β the location of the house where the i-th student lives. Some locations of houses may coincide, but no student lives in the same location where the school is situated.
Output
The output should consist of two lines. The first of them should contain one integer c β the maximum number of students that will buy shawarmas at the tent.
The second line should contain two integers p_x and p_y β the coordinates where the tent should be located. If there are multiple answers, print any of them. Note that each of p_x and p_y should be not less than 0 and not greater than 10^{9}.
Examples
Input
4 3 2
1 3
4 2
5 1
4 1
Output
3
4 2
Input
3 100 100
0 0
0 0
100 200
Output
2
99 100
Input
7 10 12
5 6
20 23
15 4
16 5
4 54
12 1
4 15
Output
4
10 11
Note
In the first example, If we build the shawarma tent in (4, 2), then the students living in (4, 2), (4, 1) and (5, 1) will visit it.
In the second example, it is possible to build the shawarma tent in (1, 1), then both students living in (0, 0) will visit it.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000000 + 7;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long T;
T = 1;
start:
while (T--) {
long long n, sx, sy;
cin >> n >> sx >> sy;
long long u = 0, d = 0, l = 0, r = 0;
for (long long i = 0; i < n; i++) {
long long x, y;
cin >> x >> y;
if (x == sx) {
if (y > sy) {
u++;
} else {
d++;
}
} else if (y == sy) {
if (x > sx) {
r++;
} else {
l++;
}
} else if (x < sx && y > sy) {
l++;
u++;
} else if (x < sx && y < sy) {
l++;
d++;
} else if (x > sx && y > sy) {
r++;
u++;
} else if (x > sx && y < sy) {
r++;
d++;
}
}
long long e = max(max(l, r), max(u, d));
cout << e << endl;
if (e == u) {
cout << sx << " " << sy + 1 << endl;
} else if (e == l) {
cout << sx - 1 << " " << sy << endl;
} else if (e == r) {
cout << sx + 1 << " " << sy << endl;
} else {
cout << sx << " " << sy - 1 << endl;
}
}
return 0;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
Find the sum of the weights of edges of the Minimum-Cost Arborescence with the root r for a given weighted directed graph G = (V, E).
Constraints
* 1 β€ |V| β€ 100
* 0 β€ |E| β€ 1,000
* 0 β€ wi β€ 10,000
* G has arborescence(s) with the root r
Input
|V| |E| r
s0 t0 w0
s1 t1 w1
:
s|E|-1 t|E|-1 w|E|-1
, where |V| is the number of vertices and |E| is the number of edges in the graph. The graph vertices are named with the numbers 0, 1,..., |V|-1 respectively. r is the root of the Minimum-Cost Arborescence.
si and ti represent source and target verticess of i-th directed edge. wi represents the weight of the i-th directed edge.
Output
Print the sum of the weights the Minimum-Cost Arborescence.
Examples
Input
4 6 0
0 1 3
0 2 2
2 0 1
2 3 1
3 0 1
3 1 5
Output
6
Input
6 10 0
0 2 7
0 1 1
0 3 5
1 4 9
2 1 6
1 3 2
3 4 3
4 2 2
2 5 8
3 5 3
Output
11
### Response
```cpp
// εθ:http://judge.u-aizu.ac.jp/onlinejudge/review.jsp?rid=1060290#1
#include <iostream>
#include <vector>
using namespace std;
const int MAX = 105;
const int INF = 10001;
void visit(int V, int G[MAX][MAX], int v, int s, int r,
vector<int> &no, vector< vector<int> > &comp,
vector<int> &prev, vector< vector<int> > &next,
vector<int> &mcost, vector<int> &mark,
int &cost, bool &found) {
if (mark[v]) {
vector<int> temp = no;
found = true;
do {
cost += mcost[v];
v = prev[v];
if (v != s) {
while (comp[v].size() > 0) {
no[comp[v].back()] = s;
comp[s].push_back(comp[v].back());
comp[v].pop_back();
}
}
} while (v != s);
//REP(i, V){
for(int i = 0;i < V;++i){
if(i != r && no[i] == s)
//REP(j, V){
for(int j = 0;j < V;++j){
if (no[j] != s && G[j][i] < INF) G[j][i] -= mcost[temp[i]];
}
}
}
mark[v] = true;
//REP(i, next[v].size())
for(int i = 0;i < next[v].size();++i)
if(no[next[v][i]] != no[v] && prev[no[next[v][i]]] == v)
if (!mark[no[next[v][i]]] || next[v][i] == s)
visit(V, G, next[v][i], s, r, no, comp, prev, next, mcost, mark, cost, found);
}
int minimumSpanningArborescence(int V, int E, int G[MAX][MAX], int r) {
vector<int> no(V);
vector< vector<int> > comp(V);
for(int i = 0;i < V;++i) comp[i].push_back(no[i] = i);
for(int cost = 0; ;) {
vector<int> prev(V, -1);
vector<int> mcost(V, INF);
for(int i = 0;i < V;++i){
for(int j = 0;j < V;++j){
if(j == r || G[i][j] == INF || no[i] == no[j] || G[i][j] > mcost[no[j]]) continue;
mcost[no[j]] = G[i][j];
prev[no[j]] = no[i];
}
}
vector< vector<int> > next(V);
//REP(i, V)
for(int i = 0;i < V;++i)
if(prev[i] >= 0)
next[prev[i]].push_back(i);
bool stop = true;
vector<int> mark(V, false);
for(int i = 0;i < V;++i)
if(i != r && !mark[i] && !comp[i].empty()) {
bool found = false;
visit(V, G, i, i, r, no, comp, prev, next, mcost, mark, cost, found);
if (found) stop = false;
}
if (stop) {
for(int i = 0;i < V;++i) if (prev[i] >= 0) cost += mcost[i];
return cost;
}
}
}
int main() {
int vNum,eNum,s;
cin >> vNum >> eNum >> s;
int G[MAX][MAX];
for(int i = 0;i < vNum;++i)
for(int j = 0;j < vNum;++j)
G[i][j] = (i == j ? 0 : INF);
for(int i = 0;i < eNum;++i){
int v,e,w;
cin >> v >> e >> w;
G[v][e] = w;
}
cout <<minimumSpanningArborescence(vNum,eNum, G, s) <<endl;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
There is a grid of size W Γ H surrounded by walls. Some cells in the grid are occupied by slimes. The slimes want to unite with each other and become a "King Slime".
In each move, a slime can move to east, west, south and north direction until it enters a cell occupied by another slime or hit the surrounding wall. If two slimes come together, they unite and become a new slime.
Your task is write a program which calculates the minimum number of moves that all the slimes unite and become a King Slime. Suppose slimes move one by one and they never move simultaneously.
Input
The first line contains three integers N (2 β€ N β€ 40,000), W and H (1 β€ W, H β€ 100,000), which denote the number of slimes, the width and the height of the grid respectively.
The following N lines describe the initial coordinates of the slimes. The i-th line contains two integers xi (1 β€ xi β€ W) and yi (1 β€ yi β€ H), which indicate the coordinates of the i-th slime . All the coordinates are 1-based.
You may assume that each cell is occupied by at most one slime initially.
Output
Output the minimum number of moves that all the slimes unite and become a King Slime.
Examples
Input
4 3 3
1 1
1 3
3 1
3 3
Output
3
Input
2 3 3
2 2
3 3
Output
2
Input
2 4 4
2 2
3 3
Output
3
Input
2 4 4
2 2
2 3
Output
1
### Response
```cpp
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <iostream>
#include <math.h>
#include <assert.h>
#include <vector>
#include <queue>
#include <string>
#include <map>
#include <set>
using namespace std;
typedef long long ll;
typedef unsigned int uint;
typedef unsigned long long ull;
static const double EPS = 1e-9;
static const double PI = acos(-1.0);
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define FOR(i, s, n) for (int i = (s); i < (int)(n); i++)
#define FOREQ(i, s, n) for (int i = (s); i <= (int)(n); i++)
#define FORIT(it, c) for (__typeof((c).begin())it = (c).begin(); it != (c).end(); it++)
#define MEMSET(v, h) memset((v), h, sizeof(v))
int n, w, h;
vector<int> xIndex[100010];
vector<int> yIndex[100010];
int xs[100010];
int ys[100010];
bool visit[100010];
int main() {
while (scanf("%d %d %d", &n, &w, &h) > 0) {
MEMSET(visit, false);
REP(i, 100010) { xIndex[i].clear(); yIndex[i].clear(); }
int edge = 0;
int ans = n - 2;
REP(i, n) {
int x, y;
scanf("%d %d", &x, &y);
if (x == 1 || x == w || y == 1 || y == h) { edge = 1; }
x--; y--;
xs[i] = x; ys[i] = y;
xIndex[x].push_back(i);
yIndex[y].push_back(i);
}
REP(i, n) {
if (visit[i]) { continue; }
visit[i] = true;
ans++;
queue<int> que;
que.push(i);
while (!que.empty()) {
int index = que.front();
que.pop();
FORIT(it, xIndex[xs[index]]) {
if (visit[*it]) { continue; }
visit[*it] = true;
que.push(*it);
}
FORIT(it, yIndex[ys[index]]) {
if (visit[*it]) { continue; }
visit[*it] = true;
que.push(*it);
}
}
}
if (ans != n - 1 && !edge) { ans++; }
printf("%d\n", ans);
}
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
You are given a permutation of n numbers p1, p2, ..., pn. We perform k operations of the following type: choose uniformly at random two indices l and r (l β€ r) and reverse the order of the elements pl, pl + 1, ..., pr. Your task is to find the expected value of the number of inversions in the resulting permutation.
Input
The first line of input contains two integers n and k (1 β€ n β€ 100, 1 β€ k β€ 109). The next line contains n integers p1, p2, ..., pn β the given permutation. All pi are different and in range from 1 to n.
The problem consists of three subproblems. The subproblems have different constraints on the input. You will get some score for the correct submission of the subproblem. The description of the subproblems follows.
* In subproblem G1 (3 points), the constraints 1 β€ n β€ 6, 1 β€ k β€ 4 will hold.
* In subproblem G2 (5 points), the constraints 1 β€ n β€ 30, 1 β€ k β€ 200 will hold.
* In subproblem G3 (16 points), the constraints 1 β€ n β€ 100, 1 β€ k β€ 109 will hold.
Output
Output the answer with absolute or relative error no more than 1e - 9.
Examples
Input
3 1
1 2 3
Output
0.833333333333333
Input
3 4
1 3 2
Output
1.458333333333334
Note
Consider the first sample test. We will randomly pick an interval of the permutation (1, 2, 3) (which has no inversions) and reverse the order of its elements. With probability <image>, the interval will consist of a single element and the permutation will not be altered. With probability <image> we will inverse the first two elements' order and obtain the permutation (2, 1, 3) which has one inversion. With the same probability we might pick the interval consisting of the last two elements which will lead to the permutation (1, 3, 2) with one inversion. Finally, with probability <image> the randomly picked interval will contain all elements, leading to the permutation (3, 2, 1) with 3 inversions. Hence, the expected number of inversions is equal to <image>.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int p[6], n, k, ans, total;
void att(int z) {
if (z == k) {
total++;
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++) ans += p[i] > p[j];
return;
}
for (int i = 0; i < n; i++)
for (int j = i; j < n; j++) {
reverse(p + i, p + j + 1);
att(z + 1);
reverse(p + i, p + j + 1);
}
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> p[i];
att(0);
cout << fixed << setprecision(12) << 1. * ans / total << endl;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
Game "Minesweeper 1D" is played on a line of squares, the line's height is 1 square, the line's width is n squares. Some of the squares contain bombs. If a square doesn't contain a bomb, then it contains a number from 0 to 2 β the total number of bombs in adjacent squares.
For example, the correct field to play looks like that: 001*2***101*. The cells that are marked with "*" contain bombs. Note that on the correct field the numbers represent the number of bombs in adjacent cells. For example, field 2* is not correct, because cell with value 2 must have two adjacent cells with bombs.
Valera wants to make a correct field to play "Minesweeper 1D". He has already painted a squared field with width of n cells, put several bombs on the field and wrote numbers into some cells. Now he wonders how many ways to fill the remaining cells with bombs and numbers are there if we should get a correct field in the end.
Input
The first line contains sequence of characters without spaces s1s2... sn (1 β€ n β€ 106), containing only characters "*", "?" and digits "0", "1" or "2". If character si equals "*", then the i-th cell of the field contains a bomb. If character si equals "?", then Valera hasn't yet decided what to put in the i-th cell. Character si, that is equal to a digit, represents the digit written in the i-th square.
Output
Print a single integer β the number of ways Valera can fill the empty cells and get a correct field.
As the answer can be rather large, print it modulo 1000000007 (109 + 7).
Examples
Input
?01???
Output
4
Input
?
Output
2
Input
**12
Output
0
Input
1
Output
0
Note
In the first test sample you can get the following correct fields: 001**1, 001***, 001*2*, 001*10.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <class P, class Q>
inline void smin(P &a, Q b) {
if (b < a) a = b;
}
template <class P, class Q>
inline void smax(P &a, Q b) {
if (a < b) a = b;
}
const int mod = 1000000000 + 7;
const int maxn = 1000000 + 100;
int n;
string s;
int dp[maxn][3];
int main() {
ios_base::sync_with_stdio(false);
cin >> s;
if (isdigit(s.front())) s.front()++;
if (isdigit(s.back())) s.back()++;
s = '*' + s + '*';
n = (int((s).size()));
dp[1][2] = 1;
for (int i = (int)(2), _n = (int)(n + 1); i < _n; i++) {
char c = s[i - 1];
char p = s[i - 2];
if (c == '*' || c == '?') {
dp[i][2] = dp[i - 1][2];
if (p == '2' || p == '?') dp[i][2] = (dp[i][2] + dp[i - 1][1]) % mod;
if (p == '1' || p == '?') dp[i][2] = (dp[i][2] + dp[i - 1][0]) % mod;
}
if (isdigit(c) || c == '?') {
dp[i][1] = dp[i - 1][2];
if (p == '1' || p == '?') dp[i][0] = (dp[i][0] + dp[i - 1][1]) % mod;
if (p == '0' || p == '?') dp[i][0] = (dp[i][0] + dp[i - 1][0]) % mod;
}
}
cout << (dp[n][0] + (long long)dp[n][1] + dp[n][2]) % mod << endl;
{ return 0; }
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
Sergey Semyonovich is a mayor of a county city N and he used to spend his days and nights in thoughts of further improvements of Nkers' lives. Unfortunately for him, anything and everything has been done already, and there are no more possible improvements he can think of during the day (he now prefers to sleep at night). However, his assistants have found a solution and they now draw an imaginary city on a paper sheet and suggest the mayor can propose its improvements.
Right now he has a map of some imaginary city with n subway stations. Some stations are directly connected with tunnels in such a way that the whole map is a tree (assistants were short on time and enthusiasm). It means that there exists exactly one simple path between each pair of station. We call a path simple if it uses each tunnel no more than once.
One of Sergey Semyonovich's favorite quality objectives is the sum of all pairwise distances between every pair of stations. The distance between two stations is the minimum possible number of tunnels on a path between them.
Sergey Semyonovich decided to add new tunnels to the subway map. In particular, he connected any two stations u and v that were not connected with a direct tunnel but share a common neighbor, i.e. there exists such a station w that the original map has a tunnel between u and w and a tunnel between w and v. You are given a task to compute the sum of pairwise distances between all pairs of stations in the new map.
Input
The first line of the input contains a single integer n (2 β€ n β€ 200 000) β the number of subway stations in the imaginary city drawn by mayor's assistants. Each of the following n - 1 lines contains two integers u_i and v_i (1 β€ u_i, v_i β€ n, u_i β v_i), meaning the station with these indices are connected with a direct tunnel.
It is guaranteed that these n stations and n - 1 tunnels form a tree.
Output
Print one integer that is equal to the sum of distances between all pairs of stations after Sergey Semyonovich draws new tunnels between all pairs of stations that share a common neighbor in the original map.
Examples
Input
4
1 2
1 3
1 4
Output
6
Input
4
1 2
2 3
3 4
Output
7
Note
In the first sample, in the new map all pairs of stations share a direct connection, so the sum of distances is 6.
In the second sample, the new map has a direct tunnel between all pairs of stations except for the pair (1, 4). For these two stations the distance is 2.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long ans;
long long num[2][200010], sz[2][200010];
vector<int> edge[200010];
void dfs1(int u, int r) {
num[0][u] = num[1][u] = sz[1][u] = 0;
sz[0][u] = 1;
for (auto v : edge[u]) {
if (v == r) continue;
dfs1(v, u);
num[0][u] += num[1][v];
num[1][u] += num[0][v] + sz[0][v];
sz[0][u] += sz[1][v];
sz[1][u] += sz[0][v];
}
}
void dfs2(int u, int r) {
ans += num[0][u] + num[1][u];
for (auto v : edge[u]) {
if (v == r) continue;
num[0][v] += num[1][u] - num[0][v] - sz[0][v];
num[1][v] += num[0][u] - num[1][v] + sz[0][u] - sz[1][v];
sz[0][v] += sz[1][u] - sz[0][v];
sz[1][v] += sz[0][u] - sz[1][v];
dfs2(v, u);
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1, u, v; i < n; i++) {
scanf("%d%d", &u, &v);
edge[u].push_back(v);
edge[v].push_back(u);
}
ans = 0;
dfs1(1, 1);
dfs2(1, 1);
printf("%lld\n", ans >> 1);
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
Oleg's favorite subjects are History and Math, and his favorite branch of mathematics is division.
To improve his division skills, Oleg came up with t pairs of integers p_i and q_i and for each pair decided to find the greatest integer x_i, such that:
* p_i is divisible by x_i;
* x_i is not divisible by q_i.
Oleg is really good at division and managed to find all the answers quickly, how about you?
Input
The first line contains an integer t (1 β€ t β€ 50) β the number of pairs.
Each of the following t lines contains two integers p_i and q_i (1 β€ p_i β€ 10^{18}; 2 β€ q_i β€ 10^{9}) β the i-th pair of integers.
Output
Print t integers: the i-th integer is the largest x_i such that p_i is divisible by x_i, but x_i is not divisible by q_i.
One can show that there is always at least one value of x_i satisfying the divisibility conditions for the given constraints.
Example
Input
3
10 4
12 6
179 822
Output
10
4
179
Note
For the first pair, where p_1 = 10 and q_1 = 4, the answer is x_1 = 10, since it is the greatest divisor of 10 and 10 is not divisible by 4.
For the second pair, where p_2 = 12 and q_2 = 6, note that
* 12 is not a valid x_2, since 12 is divisible by q_2 = 6;
* 6 is not valid x_2 as well: 6 is also divisible by q_2 = 6.
The next available divisor of p_2 = 12 is 4, which is the answer, since 4 is not divisible by 6.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t;
cin >> t;
while (t--) {
long long aa, bb;
cin >> aa >> bb;
if (aa % bb != 0) {
cout << aa << endl;
continue;
}
long long ans = 1;
vector<long long> jj;
for (long long i = 1; i * i <= bb; i++) {
if (bb % i == 0) {
jj.push_back(bb / i);
jj.push_back(i);
}
}
for (auto i : jj) {
if (i == 1) {
continue;
}
long long st = 0;
for (long long j = 2; j * j <= i; j++) {
if (i % j == 0) {
st = 1;
break;
}
}
if (st) {
continue;
}
long long co = 0;
long long dd = aa;
while (dd % i == 0) {
co++;
dd /= i;
}
long long co2 = 0;
dd = bb;
while (dd % i == 0) {
co2++;
dd /= i;
}
long long kk = 1;
for (long long j = 0; j < max(co - co2 + 1, (long long)0); j++) {
kk *= i;
}
ans = max(ans, aa / (kk));
}
cout << ans << endl;
}
return 0;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
Polycarp wants to train before another programming competition. During the first day of his training he should solve exactly 1 problem, during the second day β exactly 2 problems, during the third day β exactly 3 problems, and so on. During the k-th day he should solve k problems.
Polycarp has a list of n contests, the i-th contest consists of a_i problems. During each day Polycarp has to choose exactly one of the contests he didn't solve yet and solve it. He solves exactly k problems from this contest. Other problems are discarded from it. If there are no contests consisting of at least k problems that Polycarp didn't solve yet during the k-th day, then Polycarp stops his training.
How many days Polycarp can train if he chooses the contests optimally?
Input
The first line of the input contains one integer n (1 β€ n β€ 2 β
10^5) β the number of contests.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 β€ a_i β€ 2 β
10^5) β the number of problems in the i-th contest.
Output
Print one integer β the maximum number of days Polycarp can train if he chooses the contests optimally.
Examples
Input
4
3 1 4 1
Output
3
Input
3
1 1 1
Output
1
Input
5
1 1 1 2 2
Output
2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long int n;
cin >> n;
multiset<long long int> s;
for (long long int i = 0; i < n; i++) {
long long int x;
cin >> x;
s.insert(x);
}
long long int ans = 0;
for (long long int i = 1; i <= n; i++) {
while (s.size()) {
long long int x = *(s.begin());
if (x >= i) break;
s.erase(s.begin());
}
if (!s.size()) break;
ans++;
s.erase(s.begin());
}
cout << ans;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Vasya goes to visit his classmate Petya. Vasya knows that Petya's apartment number is n.
There is only one entrance in Petya's house and the distribution of apartments is the following: the first floor contains 2 apartments, every other floor contains x apartments each. Apartments are numbered starting from one, from the first floor. I.e. apartments on the first floor have numbers 1 and 2, apartments on the second floor have numbers from 3 to (x + 2), apartments on the third floor have numbers from (x + 3) to (2 β
x + 2), and so on.
Your task is to find the number of floor on which Petya lives. Assume that the house is always high enough to fit at least n apartments.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 1000) β the number of test cases. Then t test cases follow.
The only line of the test case contains two integers n and x (1 β€ n, x β€ 1000) β the number of Petya's apartment and the number of apartments on each floor of the house except the first one (there are two apartments on the first floor).
Output
For each test case, print the answer: the number of floor on which Petya lives.
Example
Input
4
7 3
1 5
22 5
987 13
Output
3
1
5
77
Note
Consider the first test case of the example: the first floor contains apartments with numbers 1 and 2, the second one contains apartments with numbers 3, 4 and 5, the third one contains apartments with numbers 6, 7 and 8. Therefore, Petya lives on the third floor.
In the second test case of the example, Petya lives in the apartment 1 which is on the first floor.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long double PI = acos(-1);
const long long MOD = 1e9 + 7;
const long long MOD2 = 5e6;
long long t, n, x;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> t;
while (t--) {
cin >> n >> x;
if (n <= 2) {
cout << 1 << "\n";
continue;
}
n -= 2;
long long ans = 1;
ans += (n + x - 1) / x;
cout << ans << "\n";
}
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
The ICPC committee would like to have its meeting as soon as possible to address every little issue of the next contest. However, members of the committee are so busy maniacally developing (possibly useless) programs that it is very difficult to arrange their schedules for the meeting. So, in order to settle the meeting date, the chairperson requested every member to send back a list of convenient dates by E-mail. Your mission is to help the chairperson, who is now dedicated to other issues of the contest, by writing a program that chooses the best date from the submitted lists. Your program should find the date convenient for the most members. If there is more than one such day, the earliest is the best.
Input
The input has multiple data sets, each starting with a line containing the number of committee members and the quorum of the meeting.
> N Q
Here, N, meaning the size of the committee, and Q meaning the quorum, are positive integers. N is less than 50, and, of course, Q is less than or equal to N.
N lines follow, each describing convenient dates for a committee member in the following format.
> M Date1 Date2 ... DateM
Here, M means the number of convenient dates for the member, which is an integer greater than or equal to zero. The remaining items in the line are his/her dates of convenience, which are positive integers less than 100, that is, 1 means tomorrow, 2 means the day after tomorrow, and so on. They are in ascending order without any repetition and separated by a space character. Lines have neither leading nor trailing spaces.
A line containing two zeros indicates the end of the input.
Output
For each data set, print a single line containing the date number convenient for the largest number of committee members. If there is more than one such date, print the earliest. However, if no dates are convenient for more than or equal to the quorum number of members, print 0 instead.
Example
Input
3 2
2 1 4
0
3 3 4 8
3 2
4 1 5 8 9
3 2 5 9
5 2 4 5 7 9
3 3
2 1 4
3 2 5 9
2 2 4
3 3
2 1 2
3 1 2 9
2 2 4
0 0
Output
4
5
0
2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
#define PI 4*atan(1)
#define INF 1e8
int dx[4] = {1,0,-1,0};
int dy[4] = {0,1,0,-1};
int main(){
int N, Q;
int M;
while(cin >> N >> Q, N||Q){
vector<int> P(100, 0);
for(int i = 0; i < N; i++){
cin >> M;
vector<int> Date(M);
for(int j = 0; j < M; j++){
cin >> Date[j];
P[Date[j]]++;
}
}
int m = 0, ans = 0;
for(int i = 0; i < P.size(); i++){
if(P[i] > m){
ans = i;
m = P[i];
}
}
if(m >= Q)cout << ans << endl;
else cout << 0 << endl;
}
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
Takahashi has a lot of peculiar devices. These cylindrical devices receive balls from left and right. Each device is in one of the two states A and B, and for each state, the device operates as follows:
* When a device in state A receives a ball from either side (left or right), the device throws out the ball from the same side, then immediately goes into state B.
* When a device in state B receives a ball from either side, the device throws out the ball from the other side, then immediately goes into state A.
The transition of the state of a device happens momentarily and always completes before it receives another ball.
Takahashi built a contraption by concatenating N of these devices. In this contraption,
* A ball that was thrown out from the right side of the i-th device from the left (1 \leq i \leq N-1) immediately enters the (i+1)-th device from the left side.
* A ball that was thrown out from the left side of the i-th device from the left (2 \leq i \leq N) immediately enters the (i-1)-th device from the right side.
The initial state of the i-th device from the left is represented by the i-th character in a string S. From this situation, Takahashi performed the following K times: put a ball into the leftmost device from the left side, then wait until the ball comes out of the contraption from either end. Here, it can be proved that the ball always comes out of the contraption after a finite time. Find the state of each device after K balls are processed.
Constraints
* 1 \leq N \leq 200,000
* 1 \leq K \leq 10^9
* |S|=N
* Each character in S is either `A` or `B`.
Input
The input is given from Standard Input in the following format:
N K
S
Output
Print a string that represents the state of each device after K balls are processed. The string must be N characters long, and the i-th character must correspond to the state of the i-th device from the left.
Examples
Input
5 1
ABAAA
Output
BBAAA
Input
5 2
ABAAA
Output
ABBBA
Input
4 123456789
AABB
Output
BABA
### Response
```cpp
#include <iostream>
#include <cstdlib>
#include <cstdio>
using namespace std;
inline int read()
{
int f = 1, x = 0;
char ch;
do{
ch = getchar();
if (ch == '-')
f = -1;
}while(ch < '0' || ch > '9');
do{
x = x * 10 + ch - '0';
ch = getchar();
}while(ch >= '0' && ch <= '9');
return f * x;
}
int n, k, p;
string s;
int main()
{
n = read();
k = read();
cin >> s;
if (k > n << 1)
k = (n << 1) + ((k - (n << 1)) & 1);
char ch = 'A';
for (int i = 1; i <= k; i++) {
if (s[p] == ch) {
s[p] = 'A' + 'B' - ch;
} else {
ch = 'A' + 'B' - ch;
p = (p + 1) % n;
}
}
for (int i = p; i < n; i++) {
if (s[i] == ch)
printf("A");
else
printf("B");
}
for (int i = 0; i < p; i++) {
if (s[i] == ch)
printf("A");
else
printf("B");
}
printf("\n");
return 0;
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
According to the legends the king of Berland Berl I was noted for his love of beauty and order. One day he ordered to tile the palace hall's floor where balls and receptions used to take place with black and white tiles according to a regular geometrical pattern invented by him. However, as is after the case, due to low financing there were only a black and b white tiles delivered to the palace. The other c tiles were black and white (see the picture).
<image>
The initial plan failed! Having learned of that, the king gave a new command: tile the floor with the available tiles so that no black side of a tile touched a white one. The tiles are squares of one size 1 Γ 1, every black and white tile can be rotated in one of the four ways.
The court programmer was given the task to work out the plan of tiling and he coped with the task and didn't suffer the consequences of disobedience. And can you cope with it?
Input
The first line contains given integers n and m (1 β€ n, m β€ 100) which represent the sizes of the rectangle that needs to be tiled. The next line contains non-negative numbers a, b and c, a + b + c = nm, c β₯ m.
Output
Print 2n lines containing 2m characters each β the tiling scheme. Every tile is represented by a square 2 Γ 2 in the following manner (the order corresponds to the order of the picture above):
<image> If multiple solutions exist, output any.
Examples
Input
2 2
0 0 4
Output
<span class="tex-span">\</span>../
#<span class="tex-span">\</span>/#
<span class="tex-span">\</span>##/
.<span class="tex-span">\</span>/.
Input
2 3
1 2 3
Output
###/<span class="tex-span">\</span>#
##/..<span class="tex-span">\</span>
#/....
/.....
### Response
```cpp
#include <bits/stdc++.h>
struct Tblock {
char order;
bool L, R, U, D;
};
const int maxn = 207;
int n, m;
int a, b, c;
int x, y;
Tblock block[maxn][maxn];
char Map[maxn][maxn];
void empty() {
for (int i = 0; i <= n; i++) block[i][0].R = true, block[i][m + 1].L = false;
for (int j = 0; j <= m; j++) block[0][j].D = true, block[n + 1][j].U = false;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) block[i][j].order = 'N';
}
void prepare_black() {
x = 1, y = 0;
if (a == 0) return;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
block[i][j].order = 'B';
block[i][j].L = block[i][j].R = block[i][j].U = block[i][j].D = true;
if (--a == 0) {
x = i, y = j;
return;
}
}
}
void prepare_get_other(int i, int j) {
block[i][j].order = 'O';
if (block[i][j - 1].R == block[i - 1][j].D) {
block[i][j].L = block[i][j].U = block[i][j - 1].R;
block[i][j].R = block[i][j].D = !block[i][j].L;
} else {
block[i][j].L = block[i][j].D = block[i][j - 1].R;
block[i][j].R = block[i][j].U = block[i - 1][j].D;
}
--c;
}
void prepare_check_other(int i, int j) {
if (block[i][j + 1].L == block[i - 1][j].D) {
block[i][j].R = block[i][j].U = block[i][j + 1].L;
block[i][j].L = block[i][j].D = !block[i][j].R;
} else {
block[i][j].R = block[i][j].D = block[i][j + 1].L;
block[i][j].L = block[i][j].U = block[i - 1][j].D;
}
}
void prepare_other_1() {
if (c == 0) return;
for (int j = 1; j <= y; j++) {
prepare_get_other(x + 1, j);
if (c == 0) return;
}
if (x > 1) {
for (int j = y + 1; j <= m; j++) {
prepare_get_other(x, j);
if (c == 0) return;
}
x = x + 1, y = y + 1;
} else {
if (y < m) {
prepare_get_other(x, y + 1);
x = x, y = y + 2;
}
}
}
void prepare_white() {
while (b > 0) {
if (y > m) x++, y = 1;
if (block[x][y].order == 'N') {
block[x][y].order = 'W';
block[x][y].L = block[x][y].R = block[x][y].U = block[x][y].D = false;
--b;
}
y++;
}
}
void prepare_other_2() {
while (c > 0) {
if (y > m) x++, y = 1;
if (block[x][y].order == 'N') prepare_get_other(x, y);
y++;
}
}
void prepare_check() {
for (int i = n; i >= 1; i--)
for (int j = m - 1; j >= 1; j--)
if (block[i][j].order == 'O') prepare_check_other(i, j);
}
void work() {
scanf("%d%d%d", &a, &b, &c);
empty();
prepare_black();
prepare_other_1();
prepare_white();
prepare_other_2();
prepare_check();
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
int x = (i - 1) * 2 + 1, y = (j - 1) * 2 + 1;
if (block[i][j].order == 'B') {
Map[x][y] = Map[x + 1][y] = Map[x][y + 1] = Map[x + 1][y + 1] = '#';
}
if (block[i][j].order == 'W') {
Map[x][y] = Map[x + 1][y] = Map[x][y + 1] = Map[x + 1][y + 1] = '.';
}
if (block[i][j].order == 'O') {
if (block[i][j].U == block[i][j].L) {
Map[x + 1][y] = Map[x][y + 1] = '/';
if (block[i][j].U)
Map[x][y] = '#', Map[x + 1][y + 1] = '.';
else
Map[x][y] = '.', Map[x + 1][y + 1] = '#';
} else {
Map[x][y] = Map[x + 1][y + 1] = '\\';
if (block[i][j].U)
Map[x][y + 1] = '#', Map[x + 1][y] = '.';
else
Map[x][y + 1] = '.', Map[x + 1][y] = '#';
}
}
}
for (int i = 1; i <= 2 * n; i++) {
for (int j = 1; j <= 2 * m; j++) printf("%c", Map[i][j]);
puts("");
}
}
int main() {
while (scanf("%d%d", &n, &m) != EOF) work();
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
Snuke got positive integers s_1,...,s_N from his mother, as a birthday present. There may be duplicate elements.
He will circle some of these N integers. Since he dislikes cubic numbers, he wants to ensure that if both s_i and s_j (i β j) are circled, the product s_is_j is not cubic. For example, when s_1=1,s_2=1,s_3=2,s_4=4, it is not possible to circle both s_1 and s_2 at the same time. It is not possible to circle both s_3 and s_4 at the same time, either.
Find the maximum number of integers that Snuke can circle.
Constraints
* 1 β¦ N β¦ 10^5
* 1 β¦ s_i β¦ 10^{10}
* All input values are integers.
Input
The input is given from Standard Input in the following format:
N
s_1
:
s_N
Output
Print the maximum number of integers that Snuke can circle.
Examples
Input
8
1
2
3
4
5
6
7
8
Output
6
Input
6
2
4
8
16
32
64
Output
3
Input
10
1
10
100
1000000007
10000000000
1000000009
999999999
999
999
999
Output
9
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long n,s[100005],s1[100005],maxn=2e3+50,ans;
map<long long,long long> dem,used;
int main() {
scanf("%lld",&n);
for(long long i=0;i<n;i++){
scanf("%lld",&s[i]);
long long x=s[i];
s[i]=s1[i]=1;
for(long long j=2;j<=maxn;j++){
if(x%j==0){
long long cnt=0;
while(x%j==0){
x/=j;
cnt++;
}
if(cnt%3==1){
s[i]*=j;
s1[i]*=j*j;
}else if(cnt%3==2){
s[i]*=j*j;
s1[i]*=j;
}
}
}
if(x!=1){
long long y=ceil(sqrt(x));
s[i]*=x;
if(y*y==x) s1[i]*=y;
else s1[i]*=x*x;
}
dem[s[i]]++;
}
for(long long i=0;i<n;i++){
if(!used[s[i]]){
used[s[i]]=used[s1[i]]=1;
if(s[i]==1) ans++;
else ans+=max(dem[s[i]],dem[s1[i]]);
}
}
printf("%lld",ans);
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
You are given an array of integers. Vasya can permute (change order) its integers. He wants to do it so that as many as possible integers will become on a place where a smaller integer used to stand. Help Vasya find the maximal number of such integers.
For instance, if we are given an array [10, 20, 30, 40], we can permute it so that it becomes [20, 40, 10, 30]. Then on the first and the second positions the integers became larger (20>10, 40>20) and did not on the third and the fourth, so for this permutation, the number that Vasya wants to maximize equals 2. Read the note for the first example, there is one more demonstrative test case.
Help Vasya to permute integers in such way that the number of positions in a new array, where integers are greater than in the original one, is maximal.
Input
The first line contains a single integer n (1 β€ n β€ 10^5) β the length of the array.
The second line contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9) β the elements of the array.
Output
Print a single integer β the maximal number of the array's elements which after a permutation will stand on the position where a smaller element stood in the initial array.
Examples
Input
7
10 1 1 1 5 5 3
Output
4
Input
5
1 1 1 1 1
Output
0
Note
In the first sample, one of the best permutations is [1, 5, 5, 3, 10, 1, 1]. On the positions from second to fifth the elements became larger, so the answer for this permutation is 4.
In the second sample, there is no way to increase any element with a permutation, so the answer is 0.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
vector<int> a(n);
for (int i = 0; (i) < int(n); ++(i)) scanf("%d", &a[i]);
map<int, int> b;
for (int a_i : a) {
b[a_i] += 1;
}
int answer = 0;
int place = 0;
for (auto it : b) {
int cnt = it.second;
int delta = min(place, cnt);
answer += delta;
place += cnt - delta;
}
printf("%d\n", answer);
return 0;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
Sasha has an array of integers a1, a2, ..., an. You have to perform m queries. There might be queries of two types:
1. 1 l r x β increase all integers on the segment from l to r by values x;
2. 2 l r β find <image>, where f(x) is the x-th Fibonacci number. As this number may be large, you only have to find it modulo 109 + 7.
In this problem we define Fibonacci numbers as follows: f(1) = 1, f(2) = 1, f(x) = f(x - 1) + f(x - 2) for all x > 2.
Sasha is a very talented boy and he managed to perform all queries in five seconds. Will you be able to write the program that performs as well as Sasha?
Input
The first line of the input contains two integers n and m (1 β€ n β€ 100 000, 1 β€ m β€ 100 000) β the number of elements in the array and the number of queries respectively.
The next line contains n integers a1, a2, ..., an (1 β€ ai β€ 109).
Then follow m lines with queries descriptions. Each of them contains integers tpi, li, ri and may be xi (1 β€ tpi β€ 2, 1 β€ li β€ ri β€ n, 1 β€ xi β€ 109). Here tpi = 1 corresponds to the queries of the first type and tpi corresponds to the queries of the second type.
It's guaranteed that the input will contains at least one query of the second type.
Output
For each query of the second type print the answer modulo 109 + 7.
Examples
Input
5 4
1 1 2 1 1
2 1 5
1 2 4 2
2 2 4
2 1 5
Output
5
7
9
Note
Initially, array a is equal to 1, 1, 2, 1, 1.
The answer for the first query of the second type is f(1) + f(1) + f(2) + f(1) + f(1) = 1 + 1 + 1 + 1 + 1 = 5.
After the query 1 2 4 2 array a is equal to 1, 3, 4, 3, 1.
The answer for the second query of the second type is f(3) + f(4) + f(3) = 2 + 3 + 2 = 7.
The answer for the third query of the second type is f(1) + f(3) + f(4) + f(3) + f(1) = 1 + 2 + 3 + 2 + 1 = 9.
### Response
```cpp
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast", 3, "inline")
using namespace std;
const long long Mod = 1e9 + 7;
const long long MAX_N = 100005;
struct mat {
long long A[2][2];
mat() { memset(A, 0, sizeof(A)); }
long long* operator[](long long i) { return A[i]; }
};
bool operator==(mat a, mat b) {
for (long long i = 0; i < 2; i++) {
for (long long j = 0; j < 2; j++) {
if (a[i][j] != b[i][j]) return false;
}
}
return true;
}
long long n, Q;
mat start, matrix, one;
mat operator+(mat a, mat b) {
mat c = a;
for (long long i = 0; i < 2; i++) {
for (long long j = 0; j < 2; j++) {
c[i][j] += b[i][j];
c[i][j] %= Mod;
}
}
return c;
}
mat operator*(mat a, mat b) {
mat c;
for (long long i = 0; i < 2; i++) {
for (long long j = 0; j < 2; j++) {
for (long long k = 0; k < 2; k++) {
c[i][j] += a[i][k] * b[k][j];
c[i][j] %= Mod;
}
}
}
return c;
}
mat bin_pow(mat a, long long b) {
mat ret = a;
b--;
while (b > 0) {
if (b % 2) ret = ret * a;
a = a * a;
b /= 2;
}
return ret;
}
void init() {
start[0][0] = 1;
start[0][1] = 0;
matrix[0][0] = 1;
matrix[0][1] = 1;
matrix[1][0] = 1;
one[0][0] = 1;
one[1][1] = 1;
}
struct node {
long long l, r;
mat data;
mat tag;
} T[MAX_N << 2];
void pushup(long long rt) {
if (T[rt].l == T[rt].r) return;
T[rt].data = T[(rt << 1)].data + T[(rt << 1 | 1)].data;
}
void pushdown(long long rt) {
if (T[rt].l == T[rt].r) return;
if (T[rt].tag == one) return;
T[(rt << 1)].data = T[(rt << 1)].data * T[rt].tag;
T[(rt << 1)].tag = T[(rt << 1)].tag * T[rt].tag;
T[(rt << 1 | 1)].data = T[(rt << 1 | 1)].data * T[rt].tag;
T[(rt << 1 | 1)].tag = T[(rt << 1 | 1)].tag * T[rt].tag;
T[rt].tag = one;
}
long long A[MAX_N];
void build(long long rt, long long l, long long r) {
T[rt].l = l;
T[rt].r = r;
T[rt].tag = one;
if (l == r) {
if (A[l] > 1)
T[rt].data = start * bin_pow(matrix, A[l] - 1);
else
T[rt].data = start;
return;
}
long long mid = (l + r) / 2;
build((rt << 1), l, mid);
build((rt << 1 | 1), mid + 1, r);
pushup(rt);
}
mat query(long long rt, long long l, long long r) {
pushdown(rt);
if (T[rt].l == l && T[rt].r == r) return T[rt].data;
if (r <= T[(rt << 1)].r)
return query((rt << 1), l, r);
else if (l >= T[(rt << 1 | 1)].l)
return query((rt << 1 | 1), l, r);
else
return query((rt << 1), l, T[(rt << 1)].r) +
query((rt << 1 | 1), T[(rt << 1 | 1)].l, r);
}
long long query(long long l, long long r) {
mat ret = query(1, l, r);
return ret[0][0];
}
mat mt;
void modify(long long rt, long long l, long long r) {
if (T[rt].l == l && T[rt].r == r) {
T[rt].data = T[rt].data * mt;
T[rt].tag = T[rt].tag * mt;
return;
}
pushdown(rt);
if (r <= T[(rt << 1)].r)
modify((rt << 1), l, r);
else if (l >= T[(rt << 1 | 1)].l)
modify((rt << 1 | 1), l, r);
else
modify((rt << 1), l, T[(rt << 1)].r),
modify((rt << 1 | 1), T[(rt << 1 | 1)].l, r);
pushup(rt);
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
init();
cin >> n >> Q;
for (long long i = 1; i <= n; i++) cin >> A[i];
build(1, 1, n);
while (Q--) {
long long op;
cin >> op;
if (op == 1) {
long long l, r, x;
cin >> l >> r >> x;
mt = bin_pow(matrix, x);
modify(1, l, r);
} else {
long long l, r;
cin >> l >> r;
cout << query(l, r) << endl;
}
}
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
You are given an integer N. Determine if there exists a tree with 2N vertices numbered 1 to 2N satisfying the following condition, and show one such tree if the answer is yes.
* Assume that, for each integer i between 1 and N (inclusive), Vertex i and N+i have the weight i. Then, for each integer i between 1 and N, the bitwise XOR of the weights of the vertices on the path between Vertex i and N+i (including themselves) is i.
Constraints
* N is an integer.
* 1 \leq N \leq 10^{5}
Input
Input is given from Standard Input in the following format:
N
Output
If there exists a tree satisfying the condition in the statement, print `Yes`; otherwise, print `No`. Then, if such a tree exists, print the 2N-1 edges of such a tree in the subsequent 2N-1 lines, in the following format:
a_{1} b_{1}
\vdots
a_{2N-1} b_{2N-1}
Here each pair (a_i, b_i) means that there is an edge connecting Vertex a_i and b_i. The edges may be printed in any order.
Examples
Input
3
Output
Yes
1 2
2 3
3 4
4 5
5 6
Input
1
Output
No
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
int N; cin >> N;
if(1 << (int)(log2(N + 0.1)) == N){puts("No"); return 0;}
puts("Yes");
for(int i = 1 ; i < 3 ; ++i){
cout << i << ' ' << i + 1 << endl;
cout << i + N << ' ' << i + N + 1 << endl;
}
cout << 3 << ' ' << N + 1 << endl;
for(int i = 4 ; i < N ; i += 2){
cout << i << ' ' << i + 1 << endl;
cout << i + 1 << ' ' << N + 1 << endl;
cout << N + 1 << ' ' << i + N << endl;
cout << i + N << ' ' << i + N + 1 << endl;
}
if(!(N & 1)){
int t = 1 << (int)(log2(N + 0.1));
cout << N << ' ' << t + N << endl; cout << N - t + 1 << ' ' << 2 * N << endl;
}
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
One day Petya got a set of wooden cubes as a present from his mom. Petya immediately built a whole city from these cubes.
The base of the city is an n Γ n square, divided into unit squares. The square's sides are parallel to the coordinate axes, the square's opposite corners have coordinates (0, 0) and (n, n). On each of the unit squares Petya built a tower of wooden cubes. The side of a wooden cube also has a unit length.
After that Petya went an infinitely large distance away from his masterpiece and looked at it in the direction of vector v = (vx, vy, 0). Petya wonders, how many distinct cubes are visible from this position. Help him, find this number.
Each cube includes the border. We think that a cube is visible if there is a ray emanating from some point p, belonging to the cube, in the direction of vector - v, that doesn't contain any points, belonging to other cubes.
Input
The first line contains three integers n, vx and vy (1 β€ n β€ 103, |vx|, |vy| β€ |104|, |vx| + |vy| > 0).
Next n lines contain n integers each: the j-th integer in the i-th line aij (0 β€ aij β€ 109, 1 β€ i, j β€ n) represents the height of the cube tower that stands on the unit square with opposite corners at points (i - 1, j - 1) and (i, j).
Output
Print a single integer β the number of visible cubes.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
5 -1 2
5 0 0 0 1
0 0 0 0 2
0 0 0 1 2
0 0 0 0 2
2 2 2 2 3
Output
20
Input
5 1 -2
5 0 0 0 1
0 0 0 0 2
0 0 0 1 2
0 0 0 0 2
2 2 2 2 3
Output
15
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:200000000")
const double EPS = 1E-9;
const int INF = 1000000000;
const long long INF64 = (long long)1E18;
const double PI = 3.1415926535897932384626433832795;
vector<int> md, rel;
void relax(int idx, int l, int r) {
if (rel[idx]) {
md[idx] = max(md[idx], rel[idx]);
if (l != r) {
rel[idx << 1] = max(rel[idx << 1], rel[idx]);
rel[idx << 1 | 1] = max(rel[idx << 1 | 1], rel[idx]);
}
rel[idx] = 0;
}
}
int get(int idx, int l, int r, int a, int b) {
relax(idx, l, r);
if (b < l || r < a) return INF;
if (a <= l && r <= b) return md[idx];
int mid = (l + r) >> 1;
return min(get(idx << 1, l, mid, a, b), get(idx << 1 | 1, mid + 1, r, a, b));
}
void update(int idx, int l, int r, int a, int b, int val) {
relax(idx, l, r);
if (b < l || r < a) return;
if (a <= l && r <= b) {
rel[idx] = val;
return relax(idx, l, r);
}
int mid = (l + r) >> 1;
update(idx << 1, l, mid, a, b, val);
update(idx << 1 | 1, mid + 1, r, a, b, val);
md[idx] = min(md[idx << 1], md[idx << 1 | 1]);
}
int a[1100][1100], l[1100][1100], r[1100][1100], h[1100][1100];
int main() {
int n, vx, vy;
cin >> n >> vx >> vy;
for (int i = 0; i < (int)(n); i++)
for (int j = 0; j < (int)(n); j++) scanf("%d", &a[i][j]);
vector<int> xs;
xs.reserve(n * n * 2);
vector<pair<int, pair<int, int> > > e;
e.reserve(n * n);
for (int x = 0; x < (int)(n); x++)
for (int y = 0; y < (int)(n); y++) {
l[x][y] = +INF;
r[x][y] = -INF;
h[x][y] = +INF;
for (int dx = 0; dx < (int)(2); dx++)
for (int dy = 0; dy < (int)(2); dy++) {
l[x][y] = min(l[x][y], (x + dx) * vy - (y + dy) * vx);
r[x][y] = max(r[x][y], (x + dx) * vy - (y + dy) * vx);
h[x][y] = min(h[x][y], (x + dx) * vx + (y + dy) * vy);
}
xs.push_back(l[x][y]);
xs.push_back(r[x][y]);
e.push_back(make_pair(h[x][y], make_pair(x, y)));
}
sort(xs.begin(), xs.end());
xs.erase(unique(xs.begin(), xs.end()), xs.end());
sort(e.begin(), e.end());
md.assign(xs.size() * 4, 0);
rel.assign(xs.size() * 4, 0);
long long ans = 0;
for (int i = 0; i < (int)(e.size()); i++) {
int x = e[i].second.first;
int y = e[i].second.second;
int lf = int(lower_bound(xs.begin(), xs.end(), l[x][y]) - xs.begin());
int rg = int(lower_bound(xs.begin(), xs.end(), r[x][y]) - xs.begin()) - 1;
int h = get(1, 0, (int)xs.size() - 1, lf, rg);
if (h < a[x][y]) {
ans += a[x][y] - h;
update(1, 0, (int)xs.size() - 1, lf, rg, a[x][y]);
}
}
cout << ans << endl;
return 0;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
Generalized leap year
Normally, whether or not the year x is a leap year is defined as follows.
1. If x is a multiple of 400, it is a leap year.
2. Otherwise, if x is a multiple of 100, it is not a leap year.
3. Otherwise, if x is a multiple of 4, it is a leap year.
4. If not, it is not a leap year.
This can be generalized as follows. For a sequence A1, ..., An, we define whether the year x is a "generalized leap year" as follows.
1. For the smallest i (1 β€ i β€ n) such that x is a multiple of Ai, if i is odd, it is a generalized leap year, and if it is even, it is not a generalized leap year.
2. When such i does not exist, it is not a generalized leap year if n is odd, but a generalized leap year if n is even.
For example, when A = [400, 100, 4], the generalized leap year for A is equivalent to a normal leap year.
Given the sequence A1, ..., An and the positive integers l, r. Answer the number of positive integers x such that l β€ x β€ r such that year x is a generalized leap year for A.
Input
The input consists of up to 50 datasets. Each dataset is represented in the following format.
> n l r A1 A2 ... An
The integer n satisfies 1 β€ n β€ 50. The integers l and r satisfy 1 β€ l β€ r β€ 4000. For each i, the integer Ai satisfies 1 β€ Ai β€ 4000.
The end of the input is represented by a line of three zeros.
Output
Print the answer in one line for each dataset.
Sample Input
3 1988 2014
400
100
Four
1 1000 1999
1
2 1111 3333
2
2
6 2000 3000
Five
7
11
9
3
13
0 0 0
Output for the Sample Input
7
1000
2223
785
Example
Input
3 1988 2014
400
100
4
1 1000 1999
1
2 1111 3333
2
2
6 2000 3000
5
7
11
9
3
13
0 0 0
Output
7
1000
2223
785
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
ll n,l,r;
while(1){
cin>>n>>l>>r;
if(n==0&&r==0&&l==0)break;
ll a[n];
for(ll i=0;i<n;i++)cin>>a[i];
ll res = 0;
bool flag=false;
for(ll i=l;i<=r;i++){
flag=false;
for(ll j=0;j<n;j++){
if(i%a[j]==0){
if((j+1)%2==1){
res++;
//cout<<i<<endl;
flag=true;
}else{
flag=true;
}
break;
}
}
if(!flag){
if(n%2==0)res++;
}
}
cout<<res<<endl;
}
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
Takahashi has A untasty cookies containing antidotes, B tasty cookies containing antidotes and C tasty cookies containing poison.
Eating a cookie containing poison results in a stomachache, and eating a cookie containing poison while having a stomachache results in a death. As he wants to live, he cannot eat one in such a situation. Eating a cookie containing antidotes while having a stomachache cures it, and there is no other way to cure stomachaches.
Find the maximum number of tasty cookies that Takahashi can eat.
Constraints
* 0 \leq A,B,C \leq 10^9
* A,B and C are integers.
Input
Input is given from Standard Input in the following format:
A B C
Output
Print the maximum number of tasty cookies that Takahashi can eat.
Examples
Input
3 1 4
Output
5
Input
5 2 9
Output
10
Input
8 8 1
Output
9
### Response
```cpp
#include <iostream>
#define ll long long
using namespace std;
ll x,y,z;
int main()
{
cin >>x>>y>>z;
cout <<y+min(x+y+1,z);
return 0;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
I decided to play rock-paper-scissors with a group of five good friends. Rock-paper-scissors has three hands: goo, choki, and par. If the game between goo and choki is a match between goo and choki, goo is "winning" and choki is "losing". , Par and Goo have the rule that Par is "winning" and Goo is "losing". If everyone has the same hand, or if all of Goo, Choki, and Par come out, it will be "Aiko".
Create a program that inputs the hands of five rock-paper-scissors players and outputs the wins and losses of each person. Rock-paper-scissors hands are represented by the numbers 1 for goo, 2 for choki, and 3 for par. Win / loss is represented by a number of 1, "win" is 1, "los" is 2, and "Aiko" is 3, and they are output according to the input order.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
h1
h2
h3
h4
h5
The i-th line is given the i-th hand hi (1, 2 or 3).
The number of datasets does not exceed 200.
Output
Outputs the wins and losses of 5 players for each input dataset. Output the win / loss (1, 2 or 3) of the i-th person on the i-line.
Example
Input
1
2
3
2
1
1
2
2
2
1
0
Output
3
3
3
3
3
1
2
2
2
1
### Response
```cpp
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int main(){
vector<int>V(5);
while(cin>>V[0],V[0]){
vector<int>cnt(3,0);
cnt[--V[0]]++;
for(int i=1;i<5;i++){
cin>>V[i];
cnt[--V[i]]++;
}
bool flag=false;
if(cnt[0]==5||cnt[1]==5||cnt[2]==5)flag=true;
else if(cnt[0]&&cnt[1]&&cnt[2])flag=true;
if(flag)for(int i=0;i<5;i++)cout<<3<<endl;
else for(int i=0;i<5;i++)cout<<((cnt[V[i]]&&cnt[(V[i]+1)%3])?1:2)<<endl;
}
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
This is an interactive problem. In the output section below you will see the information about flushing the output.
On Sunday Leha the hacker took Nura from the house where she lives and went with her to one of the most luxurious restaurants in ViΔkopolis. Upon arrival, they left the car in a huge parking lot near the restaurant and hurried inside the building.
In the restaurant a polite waiter immediately brought the menu to Leha and Noora, consisting of n dishes. It is interesting that all dishes in the menu are numbered with integers from 1 to n. After a little thought, the girl ordered exactly k different dishes from available in the menu. To pass the waiting time while the chefs prepare ordered dishes, the girl invited the hacker to play a game that will help them get to know each other better.
The game itself is very simple: Noora wants Leha to guess any two dishes among all ordered. At the same time, she is ready to answer only one type of questions. Leha can say two numbers x and y (1 β€ x, y β€ n). After that Noora chooses some dish a for the number x such that, at first, a is among the dishes Noora ordered (x can be equal to a), and, secondly, the value <image> is the minimum possible. By the same rules the girl chooses dish b for y. After that Noora says Β«TAKΒ» to Leha, if <image>, and Β«NIEΒ» otherwise. However, the restaurant is preparing quickly, so Leha has enough time to ask no more than 60 questions. After that he should name numbers of any two dishes Noora ordered.
Help Leha to solve this problem!
Input
There are two numbers n and k (2 β€ k β€ n β€ 105) in the single line of input denoting the number of dishes in the menu and the number of dishes Noora ordered.
Output
If you want to provide an answer, output a string of the form 2 x y (1 β€ x, y β€ n, x β y), if you think the dishes x and y was among dishes ordered by Noora. After that, flush the output and terminate your program.
Interaction
While helping Leha, you can ask queries to Noora no more than 60 times. Each query should be printed in it's own line and have the form 1 x y (1 β€ x, y β€ n). You have to both print the end-of-line character and flush the output. After flushing you should read the answer for this query from input.
After each query jury's program will print one line Β«TAKΒ» or Β«NIEΒ» (without quotes) in input stream depending on the girl's answer.
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.
Hacking
For hacking you should write numbers n and k (2 β€ k β€ n β€ 105) in the first line and, for describing dishes Noora ordered, k different integers a1, a2, ..., ak (1 β€ ai β€ n), written in ascending order in the second line. Of course, solution you want to hack won't be able to read the numbers of ordered dishes.
Example
Input
3 2
NIE
TAK
NIE
TAK
TAK
TAK
Output
1 1 2
1 2 1
1 1 3
1 3 1
1 2 3
1 3 2
2 2 3
Note
There are three dishes in sample. Noora ordered dished numberes 2 and 3, which Leha should guess. If Noora receive requests for the first dish (x = 1), then she'll choose the second dish (a = 2) as the dish with the minimum value <image>. For the second (x = 2) and the third (x = 3) dishes themselves will be optimal, because in that case <image>.
Let Leha asks Noora about the next couple of dishes:
* x = 1, y = 2, then he'll recieve Β«NIEΒ» answer, because |1 - 2| > |2 - 2|
* x = 2, y = 1, then he'll recieve Β«TAKΒ» answer, because |2 - 2| β€ |1 - 2|
* x = 1, y = 3, then he'll recieve Β«NIEΒ» answer, because |1 - 2| > |3 - 3|
* x = 3, y = 1, then he'll recieve Β«TAKΒ» answer, because |3 - 3| β€ |1 - 2|
* x = 2, y = 3, then he'll recieve Β«TAKΒ» answer, because |2 - 2| β€ |3 - 3|
* x = 3, y = 2, then he'll recieve Β«TAKΒ» answer, because |3 - 3| β€ |2 - 2|
According to the available information, it is possible to say that Nura ordered dishes with numbers 2 and 3.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <class htpe, class cmp>
using heap = priority_queue<htpe, vector<htpe>, cmp>;
template <class htpe>
using min_heap = heap<htpe, greater<htpe> >;
template <class htpe>
using max_heap = heap<htpe, less<htpe> >;
const int INF = 1791791791;
const long long INFLL = 1791791791791791791ll;
bool query(int x, int y) {
cout << 1 << " " << x << " " << y << endl;
cout.flush();
string s;
cin >> s;
return s == "TAK";
}
bool is_two_answers(int a, int b) { return query(a, b) && query(b, a); }
int find_on_segment(int l, int r, int tr) {
l--;
while (l < r - 1) {
int mid = (l + r + tr) >> 1;
if (!query(mid, mid + 1))
l = mid;
else
r = mid;
}
return r;
}
int main() {
int n, k;
cin >> n >> k;
int a = find_on_segment(1, n, 0);
int b = find_on_segment(a + 1, n, 1);
if (a + 1 > n || !is_two_answers(a, b)) b = find_on_segment(1, a - 1, 0);
cout << 2 << " " << a << " " << b << endl;
cout.flush();
return 0;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
Levko loves strings of length n, consisting of lowercase English letters, very much. He has one such string s. For each string t of length n, Levko defines its beauty relative to s as the number of pairs of indexes i, j (1 β€ i β€ j β€ n), such that substring t[i..j] is lexicographically larger than substring s[i..j].
The boy wondered how many strings t are there, such that their beauty relative to s equals exactly k. Help him, find the remainder after division this number by 1000000007 (109 + 7).
A substring s[i..j] of string s = s1s2... sn is string sisi + 1... sj.
String x = x1x2... xp is lexicographically larger than string y = y1y2... yp, if there is such number r (r < p), that x1 = y1, x2 = y2, ... , xr = yr and xr + 1 > yr + 1. The string characters are compared by their ASCII codes.
Input
The first line contains two integers n and k (1 β€ n β€ 2000, 0 β€ k β€ 2000).
The second line contains a non-empty string s of length n. String s consists only of lowercase English letters.
Output
Print a single number β the answer to the problem modulo 1000000007 (109 + 7).
Examples
Input
2 2
yz
Output
26
Input
2 3
yx
Output
2
Input
4 7
abcd
Output
21962
### Response
```cpp
#include <bits/stdc++.h>
const int MOD = 1E9 + 7;
int N, K;
char str[5000];
int dp[4000][4000];
int sum[4000];
int main() {
scanf("%d%d", &N, &K);
scanf("%s", str + 1);
dp[0][0] = 1;
sum[0] = 1;
for (int i = 1; i <= N; ++i)
for (int j = 0; j <= K; ++j) {
dp[i][j] = 1ll * (str[i] - 'a') * sum[j] % MOD;
for (int k = i - 1; k >= 0 && j - 1ll * (i - k) * (N - i + 1) >= 0; --k)
dp[i][j] = (dp[i][j] + 1ll * (25 - (str[i] - 'a')) *
dp[k][j - (i - k) * (N - i + 1)]) %
MOD;
sum[j] = (sum[j] + dp[i][j]) % MOD;
}
int tot = 0;
for (int i = 0; i <= N; ++i) tot = (tot + dp[i][K]) % MOD;
printf("%d\n", tot);
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
Indiana Jones found ancient Aztec catacombs containing a golden idol. The catacombs consists of n caves. Each pair of caves is connected with a two-way corridor that can be opened or closed. The entrance to the catacombs is in the cave 1, the idol and the exit are in the cave n.
When Indiana goes from a cave x to a cave y using an open corridor, all corridors connected to the cave x change their state: all open corridors become closed, all closed corridors become open. Indiana wants to go from cave 1 to cave n going through as small number of corridors as possible. Help him find the optimal path, or determine that it is impossible to get out of catacombs.
Input
The first line contains two integers n and m (2 β€ n β€ 3β
10^5, 0 β€ m β€ 3 β
10^5) β the number of caves and the number of open corridors at the initial moment.
The next m lines describe the open corridors. The i-th of these lines contains two integers u_i and v_i (1 β€ u_i, v_i β€ n, u_i β v_i) β the caves connected by the i-th open corridor. It is guaranteed that each unordered pair of caves is presented at most once.
Output
If there is a path to exit, in the first line print a single integer k β the minimum number of corridors Indians should pass through (1 β€ k β€ 10^6). In the second line print k+1 integers x_0, β¦, x_k β the number of caves in the order Indiana should visit them. The sequence x_0, β¦, x_k should satisfy the following:
* x_0 = 1, x_k = n;
* for each i from 1 to k the corridor from x_{i - 1} to x_i should be open at the moment Indiana walks along this corridor.
If there is no path, print a single integer -1.
We can show that if there is a path, there is a path consisting of no more than 10^6 corridors.
Examples
Input
4 4
1 2
2 3
1 3
3 4
Output
2
1 3 4
Input
4 2
1 2
2 3
Output
4
1 2 3 1 4
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
vector<int> edges[N];
set<int> record[N];
int n, m;
bool bfs() {
queue<int> q;
q.push(1);
vector<pair<int, int>> dist(n + 1, {-1, -1});
dist[1] = {0, 0};
while (!q.empty()) {
int cur = q.front();
q.pop();
for (int next : edges[cur]) {
if (dist[next].first == -1) {
dist[next].first = dist[cur].first + 1;
dist[next].second = cur;
q.push(next);
}
}
}
if (dist[n].first > 0 && dist[n].first <= 4) {
cout << dist[n].first << endl;
int cur = n;
vector<int> ans;
while (cur != 0) {
ans.push_back(cur);
cur = dist[cur].second;
}
for (int i = ans.size() - 1; i >= 0; i -= 1) cout << ans[i] << " ";
cout << endl;
return true;
} else {
for (int i = 1; i <= n; i += 1) {
if (dist[i].first == 2) {
cout << 4 << endl;
cout << 1 << " " << dist[i].second << " " << i << " 1 " << n << endl;
return true;
}
}
}
return false;
}
void dfs(int root, vector<bool> &flag, vector<pair<int, int>> &mm) {
flag[root] = false;
pair<int, int> cur{root, edges[root].size()};
for (int next : edges[root]) {
if (next == 1) cur.second -= 1;
if (flag[next]) dfs(next, flag, mm);
}
mm.push_back(cur);
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i += 1) {
int u, v;
cin >> u >> v;
edges[u].push_back(v);
edges[v].push_back(u);
record[u].insert(v);
record[v].insert(u);
}
if (bfs()) return 0;
vector<bool> flag(n + 1, true);
flag[1] = false;
for (int cur : edges[1]) {
if (!flag[cur]) continue;
vector<pair<int, int>> mm;
dfs(cur, flag, mm);
for (int i = 0; i < mm.size(); i += 1) {
if (mm[i].second + 1 < mm.size()) {
int x = mm[i].first;
for (int y : edges[x]) {
if (y == 1) continue;
for (int z : edges[y]) {
if (z != 1 && z != x && record[z].count(x) == 0) {
cout << 5 << endl;
cout << "1 " << x << " " << y << " " << z << " " << x << " " << n
<< endl;
return 0;
}
}
}
}
}
}
cout << -1 << endl;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
We have a string S consisting of lowercase English letters.
If the length of S is at most K, print S without change.
If the length of S exceeds K, extract the first K characters in S, append `...` to the end of them, and print the result.
Constraints
* K is an integer between 1 and 100 (inclusive).
* S is a string consisting of lowercase English letters.
* The length of S is between 1 and 100 (inclusive).
Input
Input is given from Standard Input in the following format:
K
S
Output
Print a string as stated in Problem Statement.
Examples
Input
7
nikoandsolstice
Output
nikoand...
Input
40
ferelibenterhominesidquodvoluntcredunt
Output
ferelibenterhominesidquodvoluntcredunt
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main()
{
unsigned int x;
string s;
cin>>x;
cin>>s;
if (s.size()<=x)cout<<s;
else cout<<s.substr(0, x)<<"...";
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
Sig has built his own keyboard. Designed for ultimate simplicity, this keyboard only has 3 keys on it: the `0` key, the `1` key and the backspace key.
To begin with, he is using a plain text editor with this keyboard. This editor always displays one string (possibly empty). Just after the editor is launched, this string is empty. When each key on the keyboard is pressed, the following changes occur to the string:
* The `0` key: a letter `0` will be inserted to the right of the string.
* The `1` key: a letter `1` will be inserted to the right of the string.
* The backspace key: if the string is empty, nothing happens. Otherwise, the rightmost letter of the string is deleted.
Sig has launched the editor, and pressed these keys N times in total. As a result, the editor displays a string s. Find the number of such ways to press the keys, modulo 10^9 + 7.
Constraints
* 1 β¦ N β¦ 5000
* 1 β¦ |s| β¦ N
* s consists of the letters `0` and `1`.
Input
The input is given from Standard Input in the following format:
N
s
Output
Print the number of the ways to press the keys N times in total such that the editor displays the string s in the end, modulo 10^9+7.
Examples
Input
3
0
Output
5
Input
300
1100100
Output
519054663
Input
5000
01000001011101000100001101101111011001000110010101110010000
Output
500886057
### Response
```cpp
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<map>
using namespace std;
typedef long long ll;
typedef double db;
#define fo(i,j,k) for(i=j;i<=k;i++)
#define fd(i,j,k) for(i=j;i>=k;i--)
#define cmax(a,b) (a=(a>b)?a:b)
#define cmin(a,b) (a=(a<b)?a:b)
const int N=5e3+5,mo=1e9+7,rt=3;
ll f[N][N],i,j,n,m;
char s[N];
int main()
{
scanf("%lld %s",&n,s+1);
m=strlen(s+1);
f[0][0]=1;
fo(i,0,n-1)
fo(j,0,i)
{
(f[i+1][j+1]+=f[i][j])%=mo;
if (j)
(f[i+1][j-1]+=f[i][j]*2)%=mo;
else (f[i+1][j]+=f[i][j])%=mo;
}
printf("%lld\n",f[n][m]);
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
Danny, the local Math Maniac, is fascinated by circles, Omkar's most recent creation. Help him solve this circle problem!
You are given n nonnegative integers a_1, a_2, ..., a_n arranged in a circle, where n must be odd (ie. n-1 is divisible by 2). Formally, for all i such that 2 β€ i β€ n, the elements a_{i - 1} and a_i are considered to be adjacent, and a_n and a_1 are also considered to be adjacent. In one operation, you pick a number on the circle, replace it with the sum of the two elements adjacent to it, and then delete the two adjacent elements from the circle. This is repeated until only one number remains in the circle, which we call the circular value.
Help Danny find the maximum possible circular value after some sequences of operations.
Input
The first line contains one odd integer n (1 β€ n < 2 β
10^5, n is odd) β the initial size of the circle.
The second line contains n integers a_{1},a_{2},...,a_{n} (0 β€ a_{i} β€ 10^9) β the initial numbers in the circle.
Output
Output the maximum possible circular value after applying some sequence of operations to the given circle.
Examples
Input
3
7 10 2
Output
17
Input
1
4
Output
4
Note
For the first test case, here's how a circular value of 17 is obtained:
Pick the number at index 3. The sum of adjacent elements equals 17. Delete 7 and 10 from the circle and replace 2 with 17.
Note that the answer may not fit in a 32-bit integer.
### Response
```cpp
#include <bits/stdc++.h>
long long int oddsum[100020], evensum[100020];
int main() {
memset(oddsum, 0, sizeof(oddsum));
memset(evensum, 0, sizeof(evensum));
int n, i;
long long int x, ans = 0, sum;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%lld", &x);
if (i & 1)
oddsum[(i >> 1) + 1] = oddsum[i >> 1] + x;
else
evensum[(i >> 1) + 1] = evensum[i >> 1] + x;
}
for (i = 0; i < n; i++) {
if (i & 1)
sum =
oddsum[(i >> 1) + 1] + evensum[(n >> 1) + 1] - evensum[(i >> 1) + 1];
else
sum = evensum[(i >> 1) + 1] + oddsum[n >> 1] - oddsum[i >> 1];
if (ans < sum) ans = sum;
}
printf("%lld\n", ans);
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
You got a box with a combination lock. The lock has a display showing n digits. There are two buttons on the box, each button changes digits on the display. You have quickly discovered that the first button adds 1 to all the digits (all digits 9 become digits 0), and the second button shifts all the digits on the display one position to the right (the last digit becomes the first one). For example, if the display is currently showing number 579, then if we push the first button, the display will show 680, and if after that we push the second button, the display will show 068.
You know that the lock will open if the display is showing the smallest possible number that can be obtained by pushing the buttons in some order. The leading zeros are ignored while comparing numbers. Now your task is to find the desired number.
Input
The first line contains a single integer n (1 β€ n β€ 1000) β the number of digits on the display.
The second line contains n digits β the initial state of the display.
Output
Print a single line containing n digits β the desired state of the display containing the smallest possible number.
Examples
Input
3
579
Output
024
Input
4
2014
Output
0142
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000 + 10;
string s, t, ans;
int main() {
int n;
scanf("%d", &n);
cin >> s;
ans = s;
for (int i = 0; i < n; i++) {
t = s.substr(i, n) + s.substr(0, i);
int x = 10 - (t[0] - '0');
for (int j = 0; j < n; j++) {
int nx = (t[j] - '0' + x) % 10;
t[j] = nx + '0';
}
ans = min(ans, t);
}
cout << ans << endl;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
The goal of the 15 puzzle problem is to complete pieces on $4 \times 4$ cells where one of the cells is empty space.
In this problem, the space is represented by 0 and pieces are represented by integers from 1 to 15 as shown below.
1 2 3 4
6 7 8 0
5 10 11 12
9 13 14 15
You can move a piece toward the empty space at one step. Your goal is to make the pieces the following configuration in the shortest move (fewest steps).
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 0
Write a program which reads an initial state of the puzzle and prints the fewest steps to solve the puzzle.
Constraints
* The given puzzle is solvable in at most 45 steps.
Input
The $4 \times 4$ integers denoting the pieces or space are given.
Output
Print the fewest steps in a line.
Example
Input
1 2 3 4
6 7 8 0
5 10 11 12
9 13 14 15
Output
8
### Response
```cpp
#include <iostream>
#define rep(i, n) for(int i=0;i<n;i++)
#define N 16
#define SQRTN 4
#define LIMIT 100
using namespace std;
int limit;
int searchV[4][2] = {{0, 1},{1, 0},{0, -1},{-1, 0}};
struct Board{
int b[N], h;
int calcHeust(void){
h = 0;
for(int i = 0; i < SQRTN; i++){
for(int j = 0; j < SQRTN; j++){
if(b[i*SQRTN + j] == N-1) continue;
h += abs(b[i*SQRTN + j]/SQRTN-i) + abs(b[i*SQRTN + j]%SQRTN-j);
}
}
return h;
}
};
void printBoard(Board b){
rep(i, SQRTN){
rep(j, SQRTN){
cout << b.b[i*SQRTN + j];
}
cout << endl;
}
}
Board currentState;
bool dfs(int depth, int prev, int cbX, int cbY){
currentState.calcHeust();
if ( currentState.h == 0) return true;
if ( depth + currentState.h > limit ) return false;
for (int d = 0 ; d < 4 ; d++ ){
int sx = cbX + searchV[d][0];
int sy = cbY + searchV[d][1];
if ( abs(d - prev) == 2 ) continue;
if ( sx < 0 || sy < 0 || sx >= SQRTN || sy >= SQRTN) continue;
swap(currentState.b[cbY*SQRTN + cbX], currentState.b[sy*SQRTN + sx]);
if (dfs(depth+1, d, sx, sy)) return true;
swap(currentState.b[cbY*SQRTN + cbX], currentState.b[sy*SQRTN + sx]);
}
return false;
}
int idastar(Board in, int px, int py){
for (limit=0;limit < LIMIT;limit++){
currentState = in;
if (dfs(0, 100, px, py)) return limit;
}
return -1;
}
int main(void){
Board init;
int p0x, p0y;
rep(i, N){
cin >> init.b[i];
if (init.b[i]==0){
init.b[i] = N;
p0y = i/SQRTN;
p0x = i%SQRTN;
}
init.b[i]--;
}
cout << idastar(init, p0x, p0y) << endl;;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
We have a grid with H rows and W columns of squares. Snuke is painting these squares in colors 1, 2, ..., N. Here, the following conditions should be satisfied:
* For each i (1 β€ i β€ N), there are exactly a_i squares painted in Color i. Here, a_1 + a_2 + ... + a_N = H W.
* For each i (1 β€ i β€ N), the squares painted in Color i are 4-connected. That is, every square painted in Color i can be reached from every square painted in Color i by repeatedly traveling to a horizontally or vertically adjacent square painted in Color i.
Find a way to paint the squares so that the conditions are satisfied. It can be shown that a solution always exists.
Constraints
* 1 β€ H, W β€ 100
* 1 β€ N β€ H W
* a_i β₯ 1
* a_1 + a_2 + ... + a_N = H W
Input
Input is given from Standard Input in the following format:
H W
N
a_1 a_2 ... a_N
Output
Print one way to paint the squares that satisfies the conditions. Output in the following format:
c_{1 1} ... c_{1 W}
:
c_{H 1} ... c_{H W}
Here, c_{i j} is the color of the square at the i-th row from the top and j-th column from the left.
Examples
Input
2 2
3
2 1 1
Output
1 1
2 3
Input
3 5
5
1 2 3 4 5
Output
1 4 4 4 3
2 5 4 5 3
2 5 5 5 3
Input
1 1
1
1
Output
1
### Response
```cpp
#include<iostream>
#include<vector>
using namespace std;
int N,H,W;
int val;
int V[10005];
int C[105][105];
int ind=1;
int main()
{
cin>>H>>W>>N;for(int i=1;i<=N;i++)cin>>V[i];
for(int i=1;i<=H;i++)
{
for(int j=(i%2 ? 1:W);j&&j<=W;j+=(i%2 ? 1:-1))
{
C[i][j]=ind;
V[ind]--;
while(!V[ind])ind++;
}
}
for(int i=1;i<=H;i++,cout<<"\n")for(int j=1;j<=W;j++)cout<<C[i][j]<<" ";
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
Arkady coordinates rounds on some not really famous competitive programming platform. Each round features n problems of distinct difficulty, the difficulties are numbered from 1 to n.
To hold a round Arkady needs n new (not used previously) problems, one for each difficulty. As for now, Arkady creates all the problems himself, but unfortunately, he can't just create a problem of a desired difficulty. Instead, when he creates a problem, he evaluates its difficulty from 1 to n and puts it into the problems pool.
At each moment when Arkady can choose a set of n new problems of distinct difficulties from the pool, he holds a round with these problems and removes them from the pool. Arkady always creates one problem at a time, so if he can hold a round after creating a problem, he immediately does it.
You are given a sequence of problems' difficulties in the order Arkady created them. For each problem, determine whether Arkady held the round right after creating this problem, or not. Initially the problems pool is empty.
Input
The first line contains two integers n and m (1 β€ n, m β€ 10^5) β the number of difficulty levels and the number of problems Arkady created.
The second line contains m integers a_1, a_2, β¦, a_m (1 β€ a_i β€ n) β the problems' difficulties in the order Arkady created them.
Output
Print a line containing m digits. The i-th digit should be 1 if Arkady held the round after creation of the i-th problem, and 0 otherwise.
Examples
Input
3 11
2 3 1 2 2 2 3 2 2 3 1
Output
00100000001
Input
4 8
4 1 3 3 2 3 3 3
Output
00001000
Note
In the first example Arkady held the round after the first three problems, because they are of distinct difficulties, and then only after the last problem.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int m, n, num, cnt[100500];
int main() {
cin >> m >> n;
for (int i = 1; i <= n; i++) {
int a;
cin >> a;
if (cnt[a] == 0) num++;
cnt[a]++;
if (num == m) {
cout << 1;
for (int j = 1; j <= m; j++) {
cnt[j]--;
if (cnt[j] == 0) num--;
}
} else
cout << 0;
}
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
You have a set of n discs, the i-th disc has radius i. Initially, these discs are split among m towers: each tower contains at least one disc, and the discs in each tower are sorted in descending order of their radii from bottom to top.
You would like to assemble one tower containing all of those discs. To do so, you may choose two different towers i and j (each containing at least one disc), take several (possibly all) top discs from the tower i and put them on top of the tower j in the same order, as long as the top disc of tower j is bigger than each of the discs you move. You may perform this operation any number of times.
For example, if you have two towers containing discs [6, 4, 2, 1] and [8, 7, 5, 3] (in order from bottom to top), there are only two possible operations:
* move disc 1 from the first tower to the second tower, so the towers are [6, 4, 2] and [8, 7, 5, 3, 1];
* move discs [2, 1] from the first tower to the second tower, so the towers are [6, 4] and [8, 7, 5, 3, 2, 1].
Let the difficulty of some set of towers be the minimum number of operations required to assemble one tower containing all of the discs. For example, the difficulty of the set of towers [[3, 1], [2]] is 2: you may move the disc 1 to the second tower, and then move both discs from the second tower to the first tower.
You are given m - 1 queries. Each query is denoted by two numbers a_i and b_i, and means "merge the towers a_i and b_i" (that is, take all discs from these two towers and assemble a new tower containing all of them in descending order of their radii from top to bottom). The resulting tower gets index a_i.
For each k β [0, m - 1], calculate the difficulty of the set of towers after the first k queries are performed.
Input
The first line of the input contains two integers n and m (2 β€ m β€ n β€ 2 β
10^5) β the number of discs and the number of towers, respectively.
The second line contains n integers t_1, t_2, ..., t_n (1 β€ t_i β€ m), where t_i is the index of the tower disc i belongs to. Each value from 1 to m appears in this sequence at least once.
Then m - 1 lines follow, denoting the queries. Each query is represented by two integers a_i and b_i (1 β€ a_i, b_i β€ m, a_i β b_i), meaning that, during the i-th query, the towers with indices a_i and b_i are merged (a_i and b_i are chosen in such a way that these towers exist before the i-th query).
Output
Print m integers. The k-th integer (0-indexed) should be equal to the difficulty of the set of towers after the first k queries are performed.
Example
Input
7 4
1 2 3 3 1 4 3
3 1
2 3
2 4
Output
5
4
2
0
Note
The towers in the example are:
* before the queries: [[5, 1], [2], [7, 4, 3], [6]];
* after the first query: [[2], [7, 5, 4, 3, 1], [6]];
* after the second query: [[7, 5, 4, 3, 2, 1], [6]];
* after the third query, there is only one tower: [7, 6, 5, 4, 3, 2, 1].
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int a, b, aa, bb, n, m, xx, group[N], la, ans;
int fa[N];
vector<int> s[N];
int find(int x) {
if (x == fa[x]) return x;
fa[x] = find(fa[x]);
return fa[x];
}
inline int read() {
int sum = 0, naga = 1;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') naga = -1;
ch = getchar();
}
while (ch <= '9' && ch >= '0') sum = sum * 10 + ch - '0', ch = getchar();
return sum * naga;
}
int main() {
n = read(), m = read();
ans = n - 1;
for (int i = 1; i <= n; i++) {
xx = read();
if (xx == la) ans--;
s[xx].push_back(i);
group[i] = xx;
fa[i] = i;
la = xx;
}
cout << ans << endl;
for (int i = 1; i < m; i++) {
aa = read(), bb = read();
a = find(aa), b = find(bb);
if (s[a].size() > s[b].size()) swap(a, b);
for (int j = 0; j < s[a].size(); j++) {
if (find(group[s[a][j] - 1]) == b) ans--;
if (find(group[s[a][j] + 1]) == b) ans--;
s[b].push_back(s[a][j]);
}
fa[a] = b;
cout << ans << endl;
}
return 0;
}
``` |
### Prompt
Create a solution in cpp for 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;
const int MAXN = 500000;
int n, m, dfs_clock;
vector<int> G[MAXN];
int node[MAXN], tim[MAXN][2];
void dfs(int cur, int fa) {
tim[cur][0] = ++dfs_clock;
for (int i = 0; i < G[cur].size(); i++) {
int u = G[cur][i];
if (u == fa) continue;
dfs(u, cur);
}
tim[cur][1] = dfs_clock;
}
long long col[MAXN << 2], setv[MAXN << 2];
int cal_col(long long col) {
int cnt = 0;
for (int i = 0; i < 63; i++) {
if ((1LL << i) & col) cnt++;
}
return cnt;
}
void pushdown(int o) {
if (setv[o] > 0) {
setv[o << 1] = setv[(o << 1) | 1] = setv[o];
setv[o] = 0;
}
}
void maintain(int o, int L, int R) {
col[o] = 0;
if (R > L) col[o] = col[o << 1] | col[(o << 1) | 1];
if (setv[o] > 0) col[o] = setv[o];
}
void update(int o, int L, int R, int ql, int qr, int c) {
if (ql <= L && qr >= R)
setv[o] = 1LL << c;
else {
pushdown(o);
int M = (L + R) >> 1;
if (ql <= M)
update(o << 1, L, M, ql, qr, c);
else
maintain(o << 1, L, M);
if (qr > M)
update((o << 1) | 1, M + 1, R, ql, qr, c);
else
maintain((o << 1) | 1, M + 1, R);
}
maintain(o, L, R);
}
long long query(int o, int L, int R, int ql, int qr) {
if (setv[o] > 0)
return setv[o];
else if (ql <= L && qr >= R)
return col[o];
int M = (L + R) >> 1;
long long ans = 0;
if (ql <= M) ans |= query(o << 1, L, M, ql, qr);
if (qr > M) ans |= query((o << 1) | 1, M + 1, R, ql, qr);
return ans;
}
int main() {
dfs_clock = 0;
cin >> n >> m;
for (int i = 1; i <= n; i++) scanf("%d", &node[i]);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
dfs(1, -1);
for (int i = 1; i <= n; i++) {
update(1, 1, n, tim[i][0], tim[i][0], node[i]);
}
for (int i = 1; i <= m; i++) {
int op, u, v;
scanf("%d", &op);
if (op == 1) {
scanf("%d%d", &u, &v);
update(1, 1, n, tim[u][0], tim[u][1], v);
} else {
scanf("%d", &u);
long long ans = query(1, 1, n, tim[u][0], tim[u][1]);
printf("%d\n", cal_col(ans));
}
}
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
The competitors of Bubble Cup X gathered after the competition and discussed what is the best way to get to know the host country and its cities.
After exploring the map of Serbia for a while, the competitors came up with the following facts: the country has V cities which are indexed with numbers from 1 to V, and there are E bi-directional roads that connect the cites. Each road has a weight (the time needed to cross that road). There are N teams at the Bubble Cup and the competitors came up with the following plan: each of the N teams will start their journey in one of the V cities, and some of the teams share the starting position.
They want to find the shortest time T, such that every team can move in these T minutes, and the number of different cities they end up in is at least K (because they will only get to know the cities they end up in). A team doesn't have to be on the move all the time, if they like it in a particular city, they can stay there and wait for the time to pass.
Please help the competitors to determine the shortest time T so it's possible for them to end up in at least K different cities or print -1 if that is impossible no matter how they move.
Note that there can exist multiple roads between some cities.
Input
The first line contains four integers: V, E, N and K (1 β€ V β€ 600, 1 β€ E β€ 20000, 1 β€ N β€ min(V, 200), 1 β€ K β€ N), number of cities, number of roads, number of teams and the smallest number of different cities they need to end up in, respectively.
The second line contains N integers, the cities where the teams start their journey.
Next E lines contain information about the roads in following format: Ai Bi Ti (1 β€ Ai, Bi β€ V, 1 β€ Ti β€ 10000), which means that there is a road connecting cities Ai and Bi, and you need Ti minutes to cross that road.
Output
Output a single integer that represents the minimal time the teams can move for, such that they end up in at least K different cities or output -1 if there is no solution.
If the solution exists, result will be no greater than 1731311.
Example
Input
6 7 5 4
5 5 2 2 5
1 3 3
1 5 2
1 6 5
2 5 4
2 6 7
3 4 11
3 5 3
Output
3
Note
Three teams start from city 5, and two teams start from city 2. If they agree to move for 3 minutes, one possible situation would be the following: Two teams in city 2, one team in city 5, one team in city 3 , and one team in city 1. And we see that there are four different cities the teams end their journey at.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
inline int read(int f = 1, int x = 0, char ch = ' ') {
while (!isdigit(ch = getchar()))
if (ch == '-') f = -1;
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return f * x;
}
const int N = 6e2 + 5, M = 4e4 + 5;
struct Edge {
int next, to, w;
Edge(int next = 0, int to = 0, int w = 0) : next(next), to(to), w(w){};
} edge[M];
int tot, head[N];
void _add(int x, int y, int z) {
edge[++tot] = Edge(head[x], y, z), head[x] = tot;
}
void add(int x, int y, int z) { _add(x, y, z), _add(y, x, z); }
int n, m, k, q, l, r, f[N][N], c[N], s[N], ans = -1, match[N], vis[N];
void dijkstra(int s, int *d) {
memset(d + 1, 0x3f, sizeof(int) * n);
priority_queue<pair<int, int> > q;
q.push(make_pair(d[s] = 0, s));
while (q.size()) {
int x = q.top().second, dx = -q.top().first;
q.pop();
if (dx != d[x]) continue;
for (int i = head[x]; i; i = edge[i].next) {
int y = edge[i].to, z = edge[i].w;
if (d[y] > d[x] + z) d[y] = d[x] + z, q.push(make_pair(-d[y], y));
}
}
}
bool dfs(int x, int mid) {
for (int y = 1; y <= n; ++y)
if (!vis[y] && f[x][y] <= mid) {
vis[y] = 1;
if (match[y] == -1 || dfs(match[y], mid)) return match[y] = x, true;
}
return false;
}
bool valid(int mid) {
int cnt = 0;
memset(match + 1, -1, sizeof(int) * n);
for (int i = 1; i <= k; ++i) {
memset(vis, 0, sizeof(vis));
if ((cnt += dfs(i, mid)) >= q) return true;
}
return false;
}
int main() {
n = read(), m = read(), k = read(), q = read();
for (int i = 1; i <= k; ++i) s[i] = read();
for (int i = 1; i <= m; ++i) {
int x = read(), y = read(), z = read();
add(x, y, z), r += z;
}
for (int i = 1; i <= k; ++i) dijkstra(s[i], f[i]);
r = min(1731311, r);
while (l <= r) {
int mid = (l + r) >> 1;
if (valid(mid))
ans = mid, r = mid - 1;
else
l = mid + 1;
}
printf("%d\n", ans);
return 0;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
Mike is trying rock climbing but he is awful at it.
There are n holds on the wall, i-th hold is at height ai off the ground. Besides, let the sequence ai increase, that is, ai < ai + 1 for all i from 1 to n - 1; we will call such sequence a track. Mike thinks that the track a1, ..., an has difficulty <image>. In other words, difficulty equals the maximum distance between two holds that are adjacent in height.
Today Mike decided to cover the track with holds hanging on heights a1, ..., an. To make the problem harder, Mike decided to remove one hold, that is, remove one element of the sequence (for example, if we take the sequence (1, 2, 3, 4, 5) and remove the third element from it, we obtain the sequence (1, 2, 4, 5)). However, as Mike is awful at climbing, he wants the final difficulty (i.e. the maximum difference of heights between adjacent holds after removing the hold) to be as small as possible among all possible options of removing a hold. The first and last holds must stay at their positions.
Help Mike determine the minimum difficulty of the track after removing one hold.
Input
The first line contains a single integer n (3 β€ n β€ 100) β the number of holds.
The next line contains n space-separated integers ai (1 β€ ai β€ 1000), where ai is the height where the hold number i hangs. The sequence ai is increasing (i.e. each element except for the first one is strictly larger than the previous one).
Output
Print a single number β the minimum difficulty of the track after removing a single hold.
Examples
Input
3
1 4 6
Output
5
Input
5
1 2 3 4 5
Output
2
Input
5
1 2 3 7 8
Output
4
Note
In the first sample you can remove only the second hold, then the sequence looks like (1, 6), the maximum difference of the neighboring elements equals 5.
In the second test after removing every hold the difficulty equals 2.
In the third test you can obtain sequences (1, 3, 7, 8), (1, 2, 7, 8), (1, 2, 3, 8), for which the difficulty is 4, 5 and 5, respectively. Thus, after removing the second element we obtain the optimal answer β 4.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
if (n == 3) {
cout << a[2] - a[0];
} else {
int max[n];
int cnt = 0;
for (int i = 1; i < n - 1; i++) {
int r[n];
int cnt1 = 0;
for (int j = 1; j < n; j++) {
if (j == i) {
r[cnt1] = a[j + 1] - a[j - 1];
cnt1++;
} else {
r[cnt1] = a[j] - a[j - 1];
cnt1++;
}
}
int m = r[0];
for (int j = 0; j < cnt1; j++) {
if (m < r[j] && r[j] != 0) {
m = r[j];
}
}
max[cnt] = m;
cnt++;
}
int y = max[0];
for (int u = 0; u < cnt; u++) {
if (y > max[u]) {
y = max[u];
}
}
cout << y;
}
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
You are given a string s consisting of exactly n characters, and each character is either '0', '1' or '2'. Such strings are called ternary strings.
Your task is to replace minimum number of characters in this string with other characters to obtain a balanced ternary string (balanced ternary string is a ternary string such that the number of characters '0' in this string is equal to the number of characters '1', and the number of characters '1' (and '0' obviously) is equal to the number of characters '2').
Among all possible balanced ternary strings you have to obtain the lexicographically (alphabetically) smallest.
Note that you can neither remove characters from the string nor add characters to the string. Also note that you can replace the given characters only with characters '0', '1' and '2'.
It is guaranteed that the answer exists.
Input
The first line of the input contains one integer n (3 β€ n β€ 3 β
10^5, n is divisible by 3) β the number of characters in s.
The second line contains the string s consisting of exactly n characters '0', '1' and '2'.
Output
Print one string β the lexicographically (alphabetically) smallest balanced ternary string which can be obtained from the given one with minimum number of replacements.
Because n is divisible by 3 it is obvious that the answer exists. And it is obvious that there is only one possible answer.
Examples
Input
3
121
Output
021
Input
6
000000
Output
001122
Input
6
211200
Output
211200
Input
6
120110
Output
120120
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int cnt[3], curr[2];
int main() {
int n;
cin >> n;
string s;
cin >> s;
for (int i = 0; i < n; i++) {
cnt[s[i] - '0']++;
}
int need = n / 3;
for (int i = 0; i < n; i++) {
if (cnt[s[i] - '0'] > need && cnt[0] < need) {
++cnt[0];
--cnt[s[i] - '0'];
s[i] = '0';
}
}
curr[0] = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '0') curr[0]++;
if (curr[0] > need && cnt[1] < need) {
s[i] = '1';
++cnt[1];
--curr[0];
}
}
for (int i = 0; i < n; i++) {
if (s[i] == '2' && cnt[2] > need && cnt[1] < need) {
s[i] = '1';
++cnt[1];
--cnt[2];
}
}
curr[0] = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '0') curr[0]++;
if (curr[0] > need && cnt[2] < need) {
s[i] = '2';
++cnt[2];
--curr[0];
}
}
curr[1] = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '1') curr[1]++;
if (curr[1] > need && cnt[2] < need) {
s[i] = '2';
++cnt[2];
--curr[1];
}
}
cout << s << endl;
return 0;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
Smart Beaver became interested in drawing. He draws suns. However, at some point, Smart Beaver realized that simply drawing suns is boring. So he decided to design a program that will process his drawings. You are given a picture drawn by the beaver. It will have two colors: one for the background and one for the suns in the image. Your task will be to count the number of suns in the image and for each of them to count the number of rays.
Sun is arbitrarily rotated ellipse with rays. Ray is a segment which connects point on boundary of the ellipse with some point outside ellipse.
<image> An image where all suns are circles. <image> An image where all suns are ellipses, their axes are parallel to the coordinate axes. <image> An image where all suns are rotated ellipses.
It is guaranteed that:
* No two suns have common points.
* The raysβ width is 3 pixels.
* The lengths of the ellipsis sunsβ axes will lie between 40 and 200 pixels.
* No two rays intersect.
* The lengths of all rays will lie between 10 and 30 pixels.
Input
The first line contains two integers h and w β the height and width of the image (1 β€ h, w β€ 1600). Next h lines will contain w space-separated integers each. They describe Smart Beaverβs picture. Each number equals either a 0 (the image background), or a 1 (the sun color).
The input limits for scoring 30 points are (subproblem F1):
* All suns on the image are circles.
The input limits for scoring 70 points are (subproblems F1+F2):
* All suns on the image are ellipses with axes parallel to the coordinate axes.
The input limits for scoring 100 points are (subproblems F1+F2+F3):
* All suns on the image are ellipses, they can be arbitrarily rotated.
Output
The first line must contain a single number k β the number of suns on the beaverβs image. The second line must contain exactly k space-separated integers, corresponding to the number of rays on each sun. The numbers of the second line must be sorted in the increasing order.
Examples
Note
For each complexity level you are suggested a sample in the initial data. You can download the samples at http://www.abbyy.ru/sun.zip.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int h, w;
int G1[2010][2010], G[2010][2010], num[100010], cnt, sum[2010][2010];
bool vis[2010][2010];
const int dh[4] = {1, -1, 0, 0};
const int dw[4] = {0, 0, 1, -1};
inline bool isray(int r, int c) {
return G1[r][c] && (sum[r + 4][c + 4] - sum[r - 5][c + 4] -
sum[r + 4][c - 5] + sum[r - 5][c - 5] <=
25);
}
void dfs(int bel, int r, int c) {
G[r][c] = bel;
for (int i = 0; i < 4; i++) {
int nr = r + dh[i], nc = c + dw[i];
if (nr <= 0 || nr > h || nc <= 0 || nc > w || G[nr][nc] || !G1[nr][nc])
continue;
dfs(bel, nr, nc);
}
}
void dfs2(int r, int c) {
vis[r][c] = true;
for (int i = 0; i < 4; i++) {
int nr = r + dh[i], nc = c + dw[i];
if (vis[nr][nc] || !isray(nr, nc)) continue;
dfs2(nr, nc);
}
}
int main() {
ios::sync_with_stdio(false);
cin >> h >> w;
for (int i = 10; i <= h + 9; i++)
for (int j = 10; j <= w + 9; j++) cin >> G1[i][j];
h += 20, w += 20;
for (int i = 1; i <= h; i++)
for (int j = 1; j <= w; j++)
sum[i][j] = sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1] + G1[i][j];
for (int i = 1; i <= h; i++)
for (int j = 1; j <= w; j++)
if (!G[i][j] && G1[i][j]) {
cnt++;
dfs(cnt, i, j);
}
for (int i = 1; i <= h; i++)
for (int j = 1; j <= w; j++)
if (!vis[i][j] && isray(i, j)) {
num[G[i][j]]++;
dfs2(i, j);
}
cout << cnt << endl;
sort(num + 1, num + cnt + 1);
for (int i = 1; i <= cnt; i++) cout << num[i] << ' ';
cout << endl;
return 0;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
Alice has a lovely piece of cloth. It has the shape of a square with a side of length a centimeters. Bob also wants such piece of cloth. He would prefer a square with a side of length b centimeters (where b < a). Alice wanted to make Bob happy, so she cut the needed square out of the corner of her piece and gave it to Bob. Now she is left with an ugly L shaped cloth (see pictures below).
Alice would like to know whether the area of her cloth expressed in square centimeters is [prime.](https://en.wikipedia.org/wiki/Prime_number) Could you help her to determine it?
Input
The first line contains a number t (1 β€ t β€ 5) β the number of test cases.
Each of the next t lines describes the i-th test case. It contains two integers a and b~(1 β€ b < a β€ 10^{11}) β the side length of Alice's square and the side length of the square that Bob wants.
Output
Print t lines, where the i-th line is the answer to the i-th test case. Print "YES" (without quotes) if the area of the remaining piece of cloth is prime, otherwise print "NO".
You can print each letter in an arbitrary case (upper or lower).
Example
Input
4
6 5
16 13
61690850361 24777622630
34 33
Output
YES
NO
NO
YES
Note
The figure below depicts the first test case. The blue part corresponds to the piece which belongs to Bob, and the red part is the piece that Alice keeps for herself. The area of the red part is 6^2 - 5^2 = 36 - 25 = 11, which is prime, so the answer is "YES".
<image>
In the second case, the area is 16^2 - 13^2 = 87, which is divisible by 3.
<image>
In the third case, the area of the remaining piece is 61690850361^2 - 24777622630^2 = 3191830435068605713421. This number is not prime because 3191830435068605713421 = 36913227731 β
86468472991 .
In the last case, the area is 34^2 - 33^2 = 67.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
bool isPrime(long long n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
vector<long long> primes;
bool prime[10005];
void seive() {
memset(prime, 1, sizeof(prime));
prime[0] = 0;
prime[1] = 0;
for (long long i = 2; i <= 10000; i++) {
if (prime[i] == 1) {
for (long long j = i * i; j <= 10000; j += i) prime[j] = 0;
}
}
}
long long power(long long a, long long b) {
long long ans = 1;
while (b > 0) {
if (b % 2 == 1) ans = (ans % 1000000007 * a % 1000000007) % 1000000007;
a = (a * a) % 1000000007;
b = b / 2;
}
return ans;
}
template <typename T>
std::string NumberToString(T Number) {
std::ostringstream ss;
ss << Number;
return ss.str();
}
string no_to_bits(long long n) {
string temp = "";
while (n) {
temp += (n % 2) + '0';
n /= 2;
}
reverse(temp.begin(), temp.end());
return temp;
}
long long bits_to_no(string s) {
long long ans = 0, var = 0;
for (int i = s.size() - 1; i >= 0; i--) {
ans += pow(2, var++) * (s[i] - '0');
}
return ans;
}
void solve() {
long long a, b;
cin >> a >> b;
if (a - b == 1 && isPrime(a + b))
cout << "YES";
else
cout << "NO";
cout << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
bool codechef = 1;
long long t = 1;
if (codechef) cin >> t;
while (t--) {
solve();
}
return 0;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
Let S(n) denote the number that represents the digits of n in sorted order. For example, S(1) = 1, S(5) = 5, S(50394) = 3459, S(353535) = 333555.
Given a number X, compute <image> modulo 109 + 7.
Input
The first line of input will contain the integer X (1 β€ X β€ 10700).
Output
Print a single integer, the answer to the question.
Examples
Input
21
Output
195
Input
345342
Output
390548434
Note
The first few values of S are 1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 11, 12, 13, 14, 15, 16, 17, 18, 19, 2, 12. The sum of these values is 195.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T read1() {
T t = 0;
char k;
bool vis = 0;
do (k = getchar()) == '-' && (vis = 1);
while ('0' > k || k > '9');
while ('0' <= k && k <= '9')
t = (t << 3) + (t << 1) + (k ^ '0'), k = getchar();
return vis ? -t : t;
}
char str[705];
int s, h[10];
long long P[705][12], C[705][10];
int main() {
scanf("%s", str + 1);
s = strlen(str + 1);
reverse(str + 1, str + s + 1);
for (int i = 0; i < 12; ++i) P[0][i] = 1;
for (int i = 0; i < 10; ++i) C[0][i] = 1;
for (int i = 1; i <= s; ++i)
for (int j = 1; j < 12; ++j) P[i][j] = P[i - 1][j] * j % 1000000007;
for (int i = 1; i <= s; ++i)
for (int j = 0; j < 10; ++j)
C[i][j] = C[i - 1][j] * (100 - 9 * j) % 1000000007;
long long ans = 0;
for (int i = s; i; --i) {
str[i] -= '0';
long long k = 0;
if (i != s) ++h[str[i + 1]];
for (int j = 0; j < str[i]; ++j) {
++h[j];
int o = 0;
for (int l = 10; --l;) {
o += h[l];
ans = (ans + P[o][10] * C[i - 1][l] - P[i - 1][10]) % 1000000007;
}
--h[j];
}
}
ans = ans * 111111112ll % 1000000007;
sort(str + 1, str + s + 1);
long long sum = 0;
for (int i = 1; i <= s; ++i) sum = (10ll * sum + str[i]) % 1000000007;
cout << (ans + sum + 1000000007) % 1000000007;
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
Petya is preparing for his birthday. He decided that there would be n different dishes on the dinner table, numbered from 1 to n. Since Petya doesn't like to cook, he wants to order these dishes in restaurants.
Unfortunately, all dishes are prepared in different restaurants and therefore Petya needs to pick up his orders from n different places. To speed up this process, he wants to order courier delivery at some restaurants. Thus, for each dish, there are two options for Petya how he can get it:
* the dish will be delivered by a courier from the restaurant i, in this case the courier will arrive in a_i minutes,
* Petya goes to the restaurant i on his own and picks up the dish, he will spend b_i minutes on this.
Each restaurant has its own couriers and they start delivering the order at the moment Petya leaves the house. In other words, all couriers work in parallel. Petya must visit all restaurants in which he has not chosen delivery, he does this consistently.
For example, if Petya wants to order n = 4 dishes and a = [3, 7, 4, 5], and b = [2, 1, 2, 4], then he can order delivery from the first and the fourth restaurant, and go to the second and third on your own. Then the courier of the first restaurant will bring the order in 3 minutes, the courier of the fourth restaurant will bring the order in 5 minutes, and Petya will pick up the remaining dishes in 1 + 2 = 3 minutes. Thus, in 5 minutes all the dishes will be at Petya's house.
Find the minimum time after which all the dishes can be at Petya's home.
Input
The first line contains one positive integer t (1 β€ t β€ 2 β
10^5) β the number of test cases. Then t test cases follow.
Each test case begins with a line containing one integer n (1 β€ n β€ 2 β
10^5) β the number of dishes that Petya wants to order.
The second line of each test case contains n integers a_1 β¦ a_n (1 β€ a_i β€ 10^9) β the time of courier delivery of the dish with the number i.
The third line of each test case contains n integers b_1 β¦ b_n (1 β€ b_i β€ 10^9) β the time during which Petya will pick up the dish with the number i.
The sum of n over all test cases does not exceed 2 β
10^5.
Output
For each test case output one integer β the minimum time after which all dishes can be at Petya's home.
Example
Input
4
4
3 7 4 5
2 1 2 4
4
1 2 3 4
3 3 3 3
2
1 2
10 10
2
10 10
1 2
Output
5
3
2
3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 100;
long long a[N], b[N], n;
bool check(long long mid) {
long long sum = 0;
for (long long i = 0; i < n; i++) {
if (mid < a[i]) {
sum += b[i];
}
}
return sum <= mid;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long T;
cin >> T;
while (T--) {
cin >> n;
for (long long i = 0; i < n; i++) cin >> a[i];
for (long long i = 0; i < n; i++) cin >> b[i];
long long l = 0, r = 1e9;
while (l < r) {
long long mid = l + r >> 1;
if (check(mid))
r = mid;
else
l = mid + 1;
}
cout << l << '\n';
}
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
Mad scientist Mike entertains himself by arranging rows of dominoes. He doesn't need dominoes, though: he uses rectangular magnets instead. Each magnet has two poles, positive (a "plus") and negative (a "minus"). If two magnets are put together at a close distance, then the like poles will repel each other and the opposite poles will attract each other.
Mike starts by laying one magnet horizontally on the table. During each following step Mike adds one more magnet horizontally to the right end of the row. Depending on how Mike puts the magnet on the table, it is either attracted to the previous one (forming a group of multiple magnets linked together) or repelled by it (then Mike lays this magnet at some distance to the right from the previous one). We assume that a sole magnet not linked to others forms a group of its own.
<image>
Mike arranged multiple magnets in a row. Determine the number of groups that the magnets formed.
Input
The first line of the input contains an integer n (1 β€ n β€ 100000) β the number of magnets. Then n lines follow. The i-th line (1 β€ i β€ n) contains either characters "01", if Mike put the i-th magnet in the "plus-minus" position, or characters "10", if Mike put the magnet in the "minus-plus" position.
Output
On the single line of the output print the number of groups of magnets.
Examples
Input
6
10
10
10
01
10
10
Output
3
Input
4
01
01
10
10
Output
2
Note
The first testcase corresponds to the figure. The testcase has three groups consisting of three, one and two magnets.
The second testcase has two groups, each consisting of two magnets.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
int prev;
scanf("%d", &prev);
int cnt = 1;
for (int i = 0; i < n - 1; i++) {
int x;
scanf("%d", &x);
if (prev != x) {
cnt += 1;
prev = x;
}
}
printf("%d\n", cnt);
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
Mad scientist Mike has constructed a rooted tree, which consists of n vertices. Each vertex is a reservoir which can be either empty or filled with water.
The vertices of the tree are numbered from 1 to n with the root at vertex 1. For each vertex, the reservoirs of its children are located below the reservoir of this vertex, and the vertex is connected with each of the children by a pipe through which water can flow downwards.
Mike wants to do the following operations with the tree:
1. Fill vertex v with water. Then v and all its children are filled with water.
2. Empty vertex v. Then v and all its ancestors are emptied.
3. Determine whether vertex v is filled with water at the moment.
Initially all vertices of the tree are empty.
Mike has already compiled a full list of operations that he wants to perform in order. Before experimenting with the tree Mike decided to run the list through a simulation. Help Mike determine what results will he get after performing all the operations.
Input
The first line of the input contains an integer n (1 β€ n β€ 500000) β the number of vertices in the tree. Each of the following n - 1 lines contains two space-separated numbers ai, bi (1 β€ ai, bi β€ n, ai β bi) β the edges of the tree.
The next line contains a number q (1 β€ q β€ 500000) β the number of operations to perform. Each of the following q lines contains two space-separated numbers ci (1 β€ ci β€ 3), vi (1 β€ vi β€ n), where ci is the operation type (according to the numbering given in the statement), and vi is the vertex on which the operation is performed.
It is guaranteed that the given graph is a tree.
Output
For each type 3 operation print 1 on a separate line if the vertex is full, and 0 if the vertex is empty. Print the answers to queries in the order in which the queries are given in the input.
Examples
Input
5
1 2
5 1
2 3
4 2
12
1 1
2 3
3 1
3 2
3 3
3 4
1 2
2 4
3 1
3 3
3 4
3 5
Output
0
0
0
1
0
1
0
1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct qwe {
int a, c;
} kkk[500005 << 1];
int m, cnt, k[500005], fa[500005], som[500005], dp[500005];
int tu[500005], fo[500005], sz[500005], w[500005], dom[500005];
int ans, uns, shu[500005 << 2], ji[500005 << 2];
void dfs1(int u, int fu) {
dp[u] = dp[fu] + 1;
sz[u] = 1;
fa[u] = fu;
som[u] = 0;
for (int i = k[u]; i; i = kkk[i].c) {
int v = kkk[i].a;
if (v == fu) continue;
dfs1(v, u);
sz[u] += sz[v];
if (sz[v] > sz[som[u]]) som[u] = v;
}
return;
}
void dfs2(int u, int fu) {
dom[u] = fu;
tu[u] = ++cnt;
fo[cnt] = u;
if (som[u]) dfs2(som[u], fu);
for (int i = k[u]; i; i = kkk[i].c) {
int v = kkk[i].a;
if (v == fa[u] || v == som[u]) continue;
dfs2(v, v);
}
w[u] = cnt;
return;
}
void dem(int bao, int ln) {
ji[bao << 1] = ji[bao << 1 | 1] = ji[bao];
if (ji[bao]) {
shu[bao << 1] = ln - ln / 2;
shu[bao << 1 | 1] = ln >> 1;
} else
shu[bao << 1] = shu[bao << 1 | 1] = 0;
ji[bao] = -1;
}
void cg(int bao, int l, int r, int q, int p, int c) {
if (p >= r && q <= l) {
shu[bao] = (r - l + 1) * c;
ji[bao] = c;
return;
}
if (ji[bao] + 1) dem(bao, r - l + 1);
int mid = l + r >> 1;
if (q <= mid) cg(bao << 1, l, mid, q, p, c);
if (p > mid) cg(bao << 1 | 1, mid + 1, r, q, p, c);
shu[bao] = shu[bao << 1 | 1] + shu[bao << 1];
return;
}
void zha(int bao, int l, int r, int q) {
if (l == r) {
ans = shu[bao];
return;
}
if (ji[bao] + 1) dem(bao, r - l + 1);
int mid = l + r >> 1;
if (q <= mid)
zha(bao << 1, l, mid, q);
else
zha(bao << 1 | 1, mid + 1, r, q);
shu[bao] = shu[bao << 1 | 1] + shu[bao << 1];
return;
}
void dd(int a) {
int b = 1;
while (dom[a] != dom[b]) {
if (dp[dom[a]] < dp[dom[b]]) swap(a, b);
cg(1, 1, m, tu[dom[a]], tu[a], 0);
a = fa[dom[a]];
}
if (dp[a] > dp[b]) swap(a, b);
cg(1, 1, m, tu[a], tu[b], 0);
return;
}
int main() {
int q, mo, lp, au;
memset(ji, -1, sizeof(ji));
scanf("%d", &m);
for (int i = 1; i < m; ++i) {
scanf("%d%d", &mo, &lp);
int v = i << 1;
kkk[v - 1].a = lp, kkk[v].a = mo;
kkk[v - 1].c = k[mo], kkk[v].c = k[lp];
k[mo] = v - 1, k[lp] = v;
}
dfs1(1, 0);
dfs2(1, 1);
scanf("%d", &q);
while (q--) {
scanf("%d%d", &au, &mo);
if (au == 1)
cg(1, 1, m, tu[mo], w[mo], 1);
else if (au == 2)
dd(mo);
else {
zha(1, 1, m, tu[mo]);
printf("%d\n", ans);
}
}
return 0;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
We will call a non-negative integer increasing if, for any two adjacent digits in its decimal representation, the digit to the right is greater than or equal to the digit to the left. For example, 1558, 11, 3 and 0 are all increasing; 10 and 20170312 are not.
Snuke has an integer N. Find the minimum number of increasing integers that can represent N as their sum.
Constraints
* 1 \leq N \leq 10^{500000}
Input
The input is given from Standard Input in the following format:
N
Output
Print the minimum number of increasing integers that can represent N as their sum.
Examples
Input
80
Output
2
Input
123456789
Output
1
Input
20170312
Output
4
Input
7204647845201772120166980358816078279571541735614841625060678056933503
Output
31
### Response
```cpp
#include <algorithm>
#include <cctype>
#include <cstdio>
#include <cstring>
using namespace std;
inline int read(int f = 1, int x = 0, char ch = ' ')
{
while(!isdigit(ch = getchar())) if(ch == '-') f = -1;
while(isdigit(ch)) x = x*10+ch-'0', ch = getchar();
return f*x;
}
const int N = 1e6+5;
char s[N];
int f, n, k, bit[N];
int main()
{
scanf("%s", s); n = strlen(s);
for(int i = 0; i < n; ++i) bit[i] = (s[n-i-1]-'0')*9;
for(int i = 0, k = 0; i < n||k; ++i) bit[i] += k, k = bit[i]/10, f += (bit[i] %= 10);
for(int k = 1; k <= n; ++k)
{
for(int i = 0, d = 9; d; ++i)
f -= bit[i], bit[i] += d, d = bit[i]/10, f += (bit[i]>=10?(bit[i] -= 10):bit[i]);
if(f <= 9*k) return printf("%d\n", k), 0;
}
return 0;
}
``` |