text
stringlengths 424
69.5k
|
|---|
### Prompt
Construct a CPP code solution to the problem outlined:
Naruto has sneaked into the Orochimaru's lair and is now looking for Sasuke. There are T rooms there. Every room has a door into it, each door can be described by the number n of seals on it and their integer energies a_1, a_2, ..., a_n. All energies a_i are nonzero and do not exceed 100 by absolute value. Also, n is even.
In order to open a door, Naruto must find such n seals with integer energies b_1, b_2, ..., b_n that the following equality holds: a_{1} ⋅ b_{1} + a_{2} ⋅ b_{2} + ... + a_{n} ⋅ b_{n} = 0. All b_i must be nonzero as well as a_i are, and also must not exceed 100 by absolute value. Please find required seals for every room there.
Input
The first line contains the only integer T (1 ≤ T ≤ 1000) standing for the number of rooms in the Orochimaru's lair. The other lines contain descriptions of the doors.
Each description starts with the line containing the only even integer n (2 ≤ n ≤ 100) denoting the number of seals.
The following line contains the space separated sequence of nonzero integers a_1, a_2, ..., a_n (|a_{i}| ≤ 100, a_{i} ≠ 0) denoting the energies of seals.
Output
For each door print a space separated sequence of nonzero integers b_1, b_2, ..., b_n (|b_{i}| ≤ 100, b_{i} ≠ 0) denoting the seals that can open the door. If there are multiple valid answers, print any. It can be proven that at least one answer always exists.
Example
Input
2
2
1 100
4
1 2 3 6
Output
-100 1
1 1 1 -1
Note
For the first door Naruto can use energies [-100, 1]. The required equality does indeed hold: 1 ⋅ (-100) + 100 ⋅ 1 = 0.
For the second door Naruto can use, for example, energies [1, 1, 1, -1]. The required equality also holds: 1 ⋅ 1 + 2 ⋅ 1 + 3 ⋅ 1 + 6 ⋅ (-1) = 0.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n, x2, x1;
cin >> t;
for (int i = 0; i < t; i++) {
cin >> n;
for (int j = 0; j < n; j += 2) {
cin >> x1 >> x2;
cout << -x2 << " " << x1 << " ";
}
cout << "\n";
}
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
PMP is getting a warrior. He is practicing a lot, but the results are not acceptable yet. This time instead of programming contests, he decided to compete in a car racing to increase the spirit of victory. He decides to choose a competition that also exhibits algorithmic features.
AlgoRace is a special league of car racing where different teams compete in a country of n cities. Cities are numbered 1 through n. Every two distinct cities in the country are connected with one bidirectional road. Each competing team should introduce one driver and a set of cars.
The competition is held in r rounds. In i-th round, drivers will start at city si and finish at city ti. Drivers are allowed to change their cars at most ki times. Changing cars can take place in any city in no time. One car can be used multiple times in one round, but total number of changes should not exceed ki. Drivers can freely choose their path to destination.
PMP has prepared m type of purpose-built cars. Beside for PMP’s driving skills, depending on properties of the car and the road, a car traverses each road in each direction in different times.
PMP Warriors wants to devise best strategies of choosing car and roads in each round to maximize the chance of winning the cup. For each round they want to find the minimum time required to finish it.
Input
The first line contains three space-separated integers n, m, r (2 ≤ n ≤ 60, 1 ≤ m ≤ 60, 1 ≤ r ≤ 105) — the number of cities, the number of different types of cars and the number of rounds in the competition, correspondingly.
Next m sets of n × n matrices of integers between 0 to 106 (inclusive) will follow — describing the time one car requires to traverse different roads. The k-th integer in j-th line of the i-th set is the time that i-th car requires to traverse the road from j-th city to k-th city. These matrices are not necessarily symmetric, but their diagonal is always zero.
Next r lines contain description of the rounds. The i-th of these lines contains space-separated integers si, ti, ki (1 ≤ si, ti ≤ n, si ≠ ti, 0 ≤ ki ≤ 1000) — the number of starting city, finishing city and the number of possible car changes in i-th round, correspondingly.
Output
For each round you should print the minimum required time to complete the round in a single line.
Examples
Input
4 2 3
0 1 5 6
2 0 3 6
1 3 0 1
6 6 7 0
0 3 5 6
2 0 1 6
1 3 0 2
6 6 7 0
1 4 2
1 4 1
1 4 3
Output
3
4
3
Input
4 2 3
0 7 3 3
8 0 10 5
1 1 0 4
8 9 2 0
0 3 3 9
7 0 4 9
3 8 0 4
4 8 9 0
2 3 3
2 1 3
1 2 2
Output
4
5
3
Note
In the first sample, in all rounds PMP goes from city #1 to city #2, then city #3 and finally city #4. But the sequences of types of the cars he uses are (1, 2, 1) in the first round and (1, 2, 2) in the second round. In the third round, although he can change his car three times, he uses the same strategy as the first round which only needs two car changes.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 62, K = 1002;
int dp[N][N][K];
int a[N][N][N];
int b[N][N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m, r;
memset(b, 10, sizeof b);
scanf("%d %d %d", &n, &m, &r);
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
for (int p = 1; p <= n; p++) {
scanf("%d", &a[i][j][p]);
}
}
}
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
for (int p = 1; p <= n; p++) {
for (int k = 1; k <= n; k++) {
long long q = a[i][j][p];
a[i][p][k] = min(a[i][p][k], a[i][p][j] + a[i][j][k]);
}
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
for (int k = 1; k <= m; k++) {
b[i][j] = min(b[i][j], a[k][i][j]);
}
}
}
memset(dp, 10, sizeof dp);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
dp[i][j][0] = b[i][j];
}
}
for (int k = 1; k < K; k++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
for (int p = 1; p <= n; p++) {
dp[i][j][k] = min(dp[i][j][k], dp[i][p][k - 1] + dp[p][j][0]);
}
}
}
}
for (int i = 0; i < r; i++) {
int s, t, k;
scanf("%d %d %d", &s, &t, &k);
printf("%d \n", dp[s][t][k]);
}
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
A classroom in a school has six rows with 3 desks in each row. Two people can use the same desk: one sitting on the left and one sitting on the right.
Some places are already occupied, and some places are vacant. Petya has just entered the class and wants to occupy the most convenient place. The conveniences of the places are shown on the picture:
<image>
Here, the desks in the top row are the closest to the blackboard, while the desks in the bottom row are the furthest from the blackboard.
You are given a plan of the class, where '*' denotes an occupied place, '.' denotes a vacant place, and the aisles are denoted by '-'.
Find any of the most convenient vacant places for Petya.
Input
The input consists of 6 lines. Each line describes one row of desks, starting from the closest to the blackboard. Each line is given in the following format: two characters, each is '*' or '.' — the description of the left desk in the current row; a character '-' — the aisle; two characters, each is '*' or '.' — the description of the center desk in the current row; a character '-' — the aisle; two characters, each is '*' or '.' — the description of the right desk in the current row. So, the length of each of the six lines is 8.
It is guaranteed that there is at least one vacant place in the classroom.
Output
Print the plan of the classroom after Petya takes one of the most convenient for him places. Mark this place with the letter 'P'. There should be exactly one letter 'P' in the plan. Petya can only take a vacant place. In all other places the output should coincide with the input.
If there are multiple answers, print any.
Examples
Input
..-**-..
..-**-..
..-..-..
..-..-..
..-..-..
..-..-..
Output
..-**-..
..-**-..
..-..-..
..-P.-..
..-..-..
..-..-..
Input
**-**-**
**-**-**
..-**-.*
**-**-**
..-..-..
..-**-..
Output
**-**-**
**-**-**
..-**-.*
**-**-**
..-P.-..
..-**-..
Input
**-**-*.
*.-*.-**
**-**-**
**-**-**
..-..-..
..-**-..
Output
**-**-*.
*.-*P-**
**-**-**
**-**-**
..-..-..
..-**-..
Note
In the first example the maximum convenience is 3.
In the second example the maximum convenience is 2.
In the third example the maximum convenience is 4.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 100005;
int main() {
vector<vector<int> > top = {
{3, 3, 0, 4, 4, 0, 3, 3}, {3, 3, 0, 4, 4, 0, 3, 3},
{2, 2, 0, 3, 3, 0, 2, 2}, {2, 2, 0, 3, 3, 0, 2, 2},
{1, 1, 0, 2, 2, 0, 1, 1}, {1, 1, 0, 2, 2, 0, 1, 1}};
int n = 6;
string m[n];
for (int i = 0; i < n; i++) cin >> m[i];
int topi, topj;
int topv = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 8; j++) {
if (m[i][j] == '.') {
if (top[i][j] > topv) {
topv = top[i][j];
topi = i;
topj = j;
}
}
}
}
m[topi][topj] = 'P';
for (int i = 0; i < n; i++, cout << endl)
for (int j = 0; j < 8; j++) cout << m[i][j];
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
There is a legend in the IT City college. A student that failed to answer all questions on the game theory exam is given one more chance by his professor. The student has to play a game with the professor.
The game is played on a square field consisting of n × n cells. Initially all cells are empty. On each turn a player chooses and paint an empty cell that has no common sides with previously painted cells. Adjacent corner of painted cells is allowed. On the next turn another player does the same, then the first one and so on. The player with no cells to paint on his turn loses.
The professor have chosen the field size n and allowed the student to choose to be the first or the second player in the game. What should the student choose to win the game? Both players play optimally.
Input
The only line of the input contains one integer n (1 ≤ n ≤ 1018) — the size of the field.
Output
Output number 1, if the player making the first turn wins when both players play optimally, otherwise print number 2.
Examples
Input
1
Output
1
Input
2
Output
2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long n;
int main() {
scanf("%I64d", &n);
cout << (n - 1) % 2 + 1;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
The Hedgehog likes to give presents to his friend, but no less he likes to receive them.
Having received another present today, the Hedgehog suddenly understood that he has no place to put it as there was no room left on the special shelf in the cupboard. He will have to choose another shelf, but which one should he choose, how large should it be?
In order to get to know this, the Hedgehog asks you to write him a program that will count the estimated number of presents that he will receive during the following N days. Besides, he is guided by the principle:
* on each holiday day the Hedgehog will necessarily receive a present,
* he receives presents at least every K days (i.e., if he received a present on the i-th day, he will receive the next present no later than on the i + K-th day).
For the given N and K, as well as the list of holidays among the following N days count the minimal number of presents that could be given to the Hedgehog. The number of today's day is zero, and you should regard today's present as already given (i.e., you shouldn't count it in the answer).
Input
The first line contains integers N and K (1 ≤ N ≤ 365, 1 ≤ K ≤ N).
The second line contains a number C which represents the number of holidays (0 ≤ C ≤ N). Then in the same line follow C numbers ranging from 1 to N which are the numbers of holiday days. The numbers are given in the increasing order, without repeating numbers among them.
Output
Print a single number — the minimal number of presents the Hedgehog will receive over the following N days.
Examples
Input
5 2
1 3
Output
3
Input
10 1
3 6 7 8
Output
10
### Response
```cpp
#include <bits/stdc++.h>
int main() {
int n, k, c;
scanf("%d%d%d", &n, &k, &c);
int i, x = 0;
int gifts = 0;
for (i = 0; i < c; i++) {
int y, z = 0;
scanf("%d", &y);
while (x != y) {
x++;
z++;
if ((z == k) && (x != y)) {
gifts++;
z = 0;
}
}
gifts++;
}
gifts += (n - x) / k;
printf("%d", gifts);
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
There is a plane like Figure 1 with 8 vertical and 8 horizontal squares. There are several bombs on that plane. Figure 2 shows an example (● = bomb).
| □ | □ | □ | □ | □ | □ | □ | □
--- | --- | --- | --- | --- | --- | --- | ---
□ | □ | □ | □ | □ | □ | □ | □
□ | □ | □ | □ | □ | □ | □ | □
□ | □ | □ | □ | □ | □ | □ | □
□ | □ | □ | □ | □ | □ | □ | □
□ | □ | □ | □ | □ | □ | □ | □
□ | □ | □ | □ | □ | □ | □ | □
□ | □ | □ | □ | □ | □ | □ | □
| □ | □ | □ | ● | □ | □ | ● | □
--- | --- | --- | --- | --- | --- | --- | ---
□ | □ | □ | □ | □ | ● | □ | □
● | □ | □ | □ | ● | □ | □ | ●
□ | □ | ● | □ | □ | □ | ● | □
□ | ● | □ | □ | □ | □ | □ | □
□ | □ | □ | □ | ● | □ | □ | □
● | □ | ● | □ | □ | □ | ● | □
□ | ● | □ | ● | □ | □ | ● | □
Figure 1 | Figure 2
When a bomb explodes, the blast affects the three squares above, below, left, and right of the bomb, and the bombs placed in those squares also explode in a chain reaction. For example, if the bomb shown in Fig. 3 explodes, the square shown in Fig. 4 will be affected by the blast.
| □ | □ | □ | □ | □ | □ | □ | □
--- | --- | --- | --- | --- | --- | --- | ---
□ | □ | □ | □ | □ | □ | □ | □
□ | □ | □ | □ | □ | □ | □ | □
□ | □ | □ | □ | □ | □ | □ | □
□ | □ | □ | □ | □ | □ | □ | □
□ | □ | □ | ● | □ | □ | □ | □
□ | □ | □ | □ | □ | □ | □ | □
□ | □ | □ | □ | □ | □ | □ | □
| □ | □ | □ | □ | □ | □ | □ | □
--- | --- | --- | --- | --- | --- | --- | ---
□ | □ | □ | □ | □ | □ | □ | □
□ | □ | □ | ■ | □ | □ | □ | □
□ | □ | □ | ■ | □ | □ | □ | □
□ | □ | □ | ■ | □ | □ | □ | □
■| ■| ■| ●| ■| ■| ■| □
□ | □ | □ | ■ | □ | □ | □ | □
□ | □ | □ | ■ | □ | □ | □ | □
Figure 3 | Figure 4
Create a program that reads the state where the bomb is placed and the position of the bomb that explodes first, and outputs the state of the final plane.
Input
The input is given in the following format:
n
(Blank line)
Data set 1
(Blank line)
Data set 2
..
..
Data set n
The first line gives the number of datasets n (n ≤ 20). Then n datasets are given. One blank line is given immediately before each dataset. Each dataset is given in the following format:
g1,1g2,1 ... g8,1
g1,2g2,2 ... g8,2
::
g1,8g2,8 ... g8,8
X
Y
The first eight lines are given eight strings representing the plane. Each string is a sequence of 8 characters, with 1 representing the square with the bomb and 0 representing the square without the bomb. The next two lines give the X and Y coordinates of the first bomb to explode. The coordinates of the upper left, lower left, upper right, and lower right are (1, 1), (1, 8), (8, 1), and (8, 8), respectively. For example, when the bomb shown in Figure 4 explodes for the first time, the coordinates given are (4, 6).
Output
Please output as follows for each data set.
Let 1 be the square with the bomb left without exploding, and 0 be the square without the bomb. Make one line of the plane one line consisting of eight numbers, and output the final plane state with a character string of eight lines. The beginning of each dataset must be output from Data x: as in the sample output. Where x is the dataset number.
Example
Input
2
00010010
00000100
10001001
00100010
01000000
00001000
10100010
01010010
2
5
00010010
00000100
10001001
00100010
01000000
00001000
10100010
01010010
2
5
Output
Data 1:
00000000
00000100
10001001
00100000
00000000
00001000
10100000
00000000
Data 2:
00000000
00000100
10001001
00100000
00000000
00001000
10100000
00000000
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
char field[8][8];
void dfs(int x,int y){
char a=field[y][x];
field[y][x]='0';
if(a=='1'){
for(int i=-3;i<=3;i++){
int ax,ay;
ax=x+i;
ay=y+i;
if(0<=ax&&ax<8&&field[y][ax]=='1')dfs(ax,y);
if(0<=ay&&ay<8&&field[ay][x]=='1')dfs(x,ay);
}
}
return;
}
int main(){
int n;
cin>>n;
for(int x=1;x<=n;x++){
for(int i=0;i<8;i++)
for(int j=0;j<8;j++)cin>>field[i][j];
int ax,ay;
cin>>ax>>ay;
dfs(ax-1,ay-1);
cout<<"Data "<<x<<':'<<endl;
for(int i=0;i<8;i++){
for(int j=0;j<8;j++){
cout<<field[i][j];
}
cout<<endl;
}
}
return 0;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
<image>
After William is done with work for the day, he enjoys playing his favorite video game.
The game happens in a 2D world, starting at turn 0. William can pick any cell in the game world and spawn in it. Then, each turn, William may remain at his current location or move from the current location (x, y) to one of the following locations: (x + 1, y), (x - 1, y), (x, y + 1), (x, y - 1).
To accelerate movement the game has n fast travel towers. i-th tower is located at location (xa_i, ya_i). To be able to instantly travel to the tower from any location in the game world it must first be activated. Activation of tower i happens at the moment when the player is in cell (xa_i, ya_i) after this the tower remains active throughout the entire game.
William also knows that the game has m quests. i-th quest can be completed instantly by being at location (xb_i, yb_i) on turn t_i.
William wants to find out the maximal number of quests he will be able to complete by optimally traversing the game world.
Input
The first line contains two integers n and m (0 ≤ n ≤ 14, 1 ≤ m ≤ 100), which are the number of towers and the number of quests, respectively.
Each of the next n lines contains two integers xa_i, ya_i (1 ≤ xa_i, ya_i ≤ 10^6), which are the coordinates of fast travel towers.
Each of the next m lines contains two integers xb_i, yb_i and t_i (1 ≤ xb_i, yb_i ≤ 10^6, 1 ≤ t_i ≤ 10^9), which are the coordinates of quests and the turn at which it may be completed.
It is guaranteed that all locations in a test are different.
Output
Print a single number — the maximal number of quests William will be able to complete.
Example
Input
3 4
1 1
2 3
5 2
2 2 12
5 1 4
6 2 11
3 5 10
Output
3
Note
In the first sample test one of the possible sequences of William's actions is as follows:
* Spawn at (3, 2)
* On turn 1 move to (4, 2)
* On turn 2 move to (5, 2). By visiting this cell William activates tower number 3.
* On turn 3 move to (5, 1), where he waits for 1 turn to complete the 2nd quest
* On turn 5 move to (5, 2)
* On turn 6 move to (5, 3)
* On turn 7 move to (5, 4)
* On turn 8 move to (5, 5)
* On turn 9 move to (4, 5)
* On turn 10 move to (3, 5). By moving to this location William will complete the 4th quest
* On turn 10 instantly move to an already activated fast travel tower at (5, 2)
* On turn 11 move to (6, 2). By moving to this location William will complete the 3rd quest
* William will not be able to complete the quest number 1, because the tower at (2, 3) was not activated
### Response
```cpp
#include<map>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<vector>
#include<iostream>
#include<algorithm>
using namespace std;
const int oo=2000000000;
const int maxn=15;
const int maxm=100+5;
int f[1<<14][maxm], g[1<<14][maxm];
int xa[maxn], ya[maxn];
int xb[maxm], yb[maxm], t[maxm];
int _xb[maxm], _yb[maxm], _t[maxm];
int n,m, res=0;
vector< pair<int,int> > xxx;
int daa[1<<maxn][maxn], dab[1<<maxn][maxm];
int waa[maxm][maxm], wab[maxm][maxm], wbb[maxm][maxm];
int main()
{
scanf("%d%d",&n,&m);
for (int i=0;i<n;i++)
scanf("%d%d",&xa[i], &ya[i]);
for (int i=0;i<m;i++)
{
scanf("%d%d%d",&_xb[i], &_yb[i], &_t[i]);
xxx.push_back(make_pair(_t[i], i));
}
sort(xxx.begin(), xxx.end());
for (int i=0;i<m;i++)
{
xb[i+1]= _xb[xxx[i].second];
yb[i+1]= _yb[xxx[i].second];
t[i+1]= _t[xxx[i].second];
}
for (int i=0;i<n;i++)
{
for (int j=0;j<n;j++)
waa[i][j]=abs(xa[i]-xa[j])+abs(ya[i]-ya[j]);
for (int j=0;j<=m;j++)
wab[i][j]=abs(xa[i]-xb[j])+abs(ya[i]-yb[j]);
}
for (int i=0;i<=m;i++)
for (int j=0;j<=m;j++)
wbb[i][j]=abs(xb[i]-xb[j])+abs(yb[i]-yb[j]);
for (int i=0;i<(1<<n);i++)
{
for (int j=0;j<n;j++)
if (i&(1<<j)) daa[i][j]=0;
else
{
daa[i][j]=oo;
for (int k=0;k<n;k++)
if (i&(1<<k)) daa[i][j]=min(daa[i][j], waa[j][k]);
}
for (int j=0;j<=m;j++)
{
dab[i][j]=oo;
for (int k=0;k<n;k++)
if (i&(1<<k)) dab[i][j]=min(dab[i][j], wab[k][j]);
}
}
for (int i=0;i<(1<<n);i++)
for (int j=0;j<=m;j++)
{
f[i][j]=0;
g[i][j]=oo;
}
for (int i=1;i<=m;i++)
f[0][i]=1;
for (int i=0;i<n;i++)
g[1<<i][0]=0;
for (int i=0;i<(1<<n);i++)
for (int j=0;j<=m;j++)
{
if (f[i][j])
{
res=max(res, f[i][j]);
for (int k=j+1;k<=m;k++)
if (t[j]+min(dab[i][k], wbb[j][k])<=t[k])
f[i][k]=max(f[i][k], f[i][j]+1);
for (int k=0;k<n;k++)
if (!(i&(1<<k)))
g[i+(1<<k)][f[i][j]]=min(g[i+(1<<k)][f[i][j]], t[j]+min(daa[i][k], wab[k][j]));
}
if (g[i][j]<oo)
{
res=max(res,j);
for (int k=0;k<n;k++)
if (!(i&(1<<k)))
g[i+(1<<k)][j]=min(g[i+(1<<k)][j], g[i][j]+daa[i][k]);
for (int k=j+1;k<=m;k++)
if (g[i][j]+dab[i][k]<=t[k])
f[i][k]=max(f[i][k], j+1);
}
}
printf("%d\n", res);
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
Recently an official statement of the world Olympic Committee said that the Olympic Winter Games 2030 will be held in Tomsk. The city officials decided to prepare for the Olympics thoroughly and to build all the necessary Olympic facilities as early as possible. First, a biathlon track will be built.
To construct a biathlon track a plot of land was allocated, which is a rectangle divided into n × m identical squares. Each of the squares has two coordinates: the number of the row (from 1 to n), where it is located, the number of the column (from 1 to m), where it is located. Also each of the squares is characterized by its height. During the sports the biathletes will have to move from one square to another. If a biathlete moves from a higher square to a lower one, he makes a descent. If a biathlete moves from a lower square to a higher one, he makes an ascent. If a biathlete moves between two squares with the same height, then he moves on flat ground.
The biathlon track should be a border of some rectangular area of the allocated land on which biathletes will move in the clockwise direction. It is known that on one move on flat ground an average biathlete spends tp seconds, an ascent takes tu seconds, a descent takes td seconds. The Tomsk Administration wants to choose the route so that the average biathlete passes it in as close to t seconds as possible. In other words, the difference between time ts of passing the selected track and t should be minimum.
For a better understanding you can look at the first sample of the input data. In this sample n = 6, m = 7, and the administration wants the track covering time to be as close to t = 48 seconds as possible, also, tp = 3, tu = 6 and td = 2. If we consider the rectangle shown on the image by arrows, the average biathlete can move along the boundary in a clockwise direction in exactly 48 seconds. The upper left corner of this track is located in the square with the row number 4, column number 3 and the lower right corner is at square with row number 6, column number 7.
<image>
Among other things the administration wants all sides of the rectangle which boundaries will be the biathlon track to consist of no less than three squares and to be completely contained within the selected land.
You are given the description of the given plot of land and all necessary time values. You are to write the program to find the most suitable rectangle for a biathlon track. If there are several such rectangles, you are allowed to print any of them.
Input
The first line of the input contains three integers n, m and t (3 ≤ n, m ≤ 300, 1 ≤ t ≤ 109) — the sizes of the land plot and the desired distance covering time.
The second line also contains three integers tp, tu and td (1 ≤ tp, tu, td ≤ 100) — the time the average biathlete needs to cover a flat piece of the track, an ascent and a descent respectively.
Then n lines follow, each line contains m integers that set the heights of each square of the given plot of land. Each of the height values is a positive integer, not exceeding 106.
Output
In a single line of the output print four positive integers — the number of the row and the number of the column of the upper left corner and the number of the row and the number of the column of the lower right corner of the rectangle that is chosen for the track.
Examples
Input
6 7 48
3 6 2
5 4 8 3 3 7 9
4 1 6 8 7 1 1
1 6 4 6 4 8 6
7 2 6 1 6 9 4
1 9 8 6 3 9 2
4 5 6 8 4 3 7
Output
4 3 6 7
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int max_n = 301;
int a[max_n][max_n];
int n, m, t, tu, tp, td;
inline int go_value(int from, int to) {
if (from == to) return tp;
if (from > to) return td;
return tu;
}
int str_r[max_n][max_n];
int str_l[max_n][max_n];
int stl_u[max_n][max_n];
int stl_d[max_n][max_n];
inline int get_str_r(int str, int l, int r) {
return str_r[str][l] - str_r[str][r];
}
inline int get_str_l(int str, int l, int r) {
return str_l[str][r] - str_l[str][l];
}
inline int get_stl_u(int stl, int u, int d) {
return stl_u[d][stl] - stl_u[u][stl];
}
inline int get_stl_d(int stl, int u, int d) {
return stl_d[u][stl] - stl_d[d][stl];
}
inline int get_sum1(int left, int right, int down) {
return get_str_l(down, left, right) + get_stl_u(left, 0, down) +
get_stl_d(right, 0, down);
}
const int max_val = 2e5;
int values[max_n];
int ids[max_val];
int ans_value = -1;
int ans_left;
int ans_right;
int ans_down;
int ans_up;
void update_ans(int _ans_value, int _ans_left, int _ans_right, int _ans_up,
int _ans_down) {
_ans_value = abs(_ans_value - t);
if (ans_value == -1 || _ans_value < ans_value) {
ans_value = _ans_value;
ans_left = _ans_left;
ans_right = _ans_right;
ans_down = _ans_down;
ans_up = _ans_up;
}
}
int main() {
scanf("%d%d%d", &n, &m, &t);
scanf("%d%d%d", &tp, &tu, &td);
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) scanf("%d", &a[i][j]);
for (int i = 0; i < n; ++i) {
str_r[i][m - 1] = 0;
for (int j = m - 2; j >= 0; --j) {
str_r[i][j] = str_r[i][j + 1] + go_value(a[i][j], a[i][j + 1]);
}
str_l[i][0] = 0;
for (int j = 1; j < m; ++j) {
str_l[i][j] = str_l[i][j - 1] + go_value(a[i][j], a[i][j - 1]);
}
}
for (int j = 0; j < m; ++j) {
stl_u[0][j] = 0;
for (int i = 1; i < n; ++i) {
stl_u[i][j] = stl_u[i - 1][j] + go_value(a[i][j], a[i - 1][j]);
}
stl_d[n - 1][j] = 0;
for (int i = n - 2; i >= 0; --i) {
stl_d[i][j] = stl_d[i + 1][j] + go_value(a[i][j], a[i + 1][j]);
}
}
for (int i = 0; i < max_val; ++i) ids[i] = -1;
set<int> s;
set<int>::iterator itr;
for (int left = 0; left < m; ++left)
for (int right = left + 2; right < m; ++right) {
for (int down = 0; down < n; ++down)
values[down] = get_sum1(left, right, down);
for (int down = 1; down < n; ++down) {
if (ids[values[down]] == -1) {
s.insert(values[down]);
}
ids[values[down]] = down;
}
for (int up = 0; up + 2 < n; ++up) {
if (ids[values[up + 1]] == up + 1) {
s.erase(values[up + 1]);
ids[values[up + 1]] = -1;
}
int ct = get_str_r(up, left, right) - get_stl_u(left, 0, up) -
get_stl_d(right, 0, up);
int tt = t - ct;
itr = s.lower_bound(tt);
if (itr != s.end()) {
int x = (*itr);
update_ans(ct + x, left, right, up, ids[x]);
}
if (itr != s.begin()) {
--itr;
int x = (*itr);
update_ans(ct + x, left, right, up, ids[x]);
}
}
s.erase(values[n - 1]);
ids[values[n - 1]] = -1;
}
printf("%d %d %d %d\n", ans_up + 1, ans_left + 1, ans_down + 1,
ans_right + 1);
return 0;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
Gargari got bored to play with the bishops and now, after solving the problem about them, he is trying to do math homework. In a math book he have found k permutations. Each of them consists of numbers 1, 2, ..., n in some order. Now he should find the length of the longest common subsequence of these permutations. Can you help Gargari?
You can read about longest common subsequence there: https://en.wikipedia.org/wiki/Longest_common_subsequence_problem
Input
The first line contains two integers n and k (1 ≤ n ≤ 1000; 2 ≤ k ≤ 5). Each of the next k lines contains integers 1, 2, ..., n in some order — description of the current permutation.
Output
Print the length of the longest common subsequence.
Examples
Input
4 3
1 4 2 3
4 1 2 3
1 2 4 3
Output
3
Note
The answer for the first test sample is subsequence [1, 2, 3].
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int d[2000][2000], t[2000], us[2000], n;
int dfs(int v) {
if (us[v] == 1) return t[v];
us[v] = 1;
for (int i = 1; i <= n; ++i) {
if (d[v][i] == 1) t[v] = max(dfs(i), t[v]);
}
t[v]++;
return t[v];
}
int m, i, j, k, a[2000], ans;
int main() {
cin >> n >> m;
for (i = 1; i <= n; ++i) {
for (j = 1; j <= n; ++j) d[i][j] = 1;
}
for (i = 0; i < m; ++i) {
for (j = 0; j < n; ++j) {
cin >> a[j];
for (k = 0; k <= j; ++k) {
d[a[j]][a[k]] = 0;
}
}
}
for (i = 1; i <= n; ++i) {
ans = max(ans, dfs(i));
}
cout << ans << endl;
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
You are given a rectangular board of M × N squares. Also you are given an unlimited number of standard domino pieces of 2 × 1 squares. You are allowed to rotate the pieces. You are asked to place as many dominoes as possible on the board so as to meet the following conditions:
1. Each domino completely covers two squares.
2. No two dominoes overlap.
3. Each domino lies entirely inside the board. It is allowed to touch the edges of the board.
Find the maximum number of dominoes, which can be placed under these restrictions.
Input
In a single line you are given two integers M and N — board sizes in squares (1 ≤ M ≤ N ≤ 16).
Output
Output one number — the maximal number of dominoes, which can be placed.
Examples
Input
2 4
Output
4
Input
3 3
Output
4
### Response
```cpp
#include <bits/stdc++.h>
int main() {
int M, N, S;
scanf("%d%d", &M, &N);
if (M >= 1 && N <= 16) {
S = (M * N) / 2;
}
printf("%d", S);
return 0;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
Dr. Moriarty is about to send a message to Sherlock Holmes. He has a string s.
String p is called a substring of string s if you can read it starting from some position in the string s. For example, string "aba" has six substrings: "a", "b", "a", "ab", "ba", "aba".
Dr. Moriarty plans to take string s and cut out some substring from it, let's call it t. Then he needs to change the substring t zero or more times. As a result, he should obtain a fixed string u (which is the string that should be sent to Sherlock Holmes). One change is defined as making one of the following actions:
* Insert one letter to any end of the string.
* Delete one letter from any end of the string.
* Change one letter into any other one.
Moriarty is very smart and after he chooses some substring t, he always makes the minimal number of changes to obtain u.
Help Moriarty choose the best substring t from all substrings of the string s. The substring t should minimize the number of changes Moriarty should make to obtain the string u from it.
Input
The first line contains a non-empty string s, consisting of lowercase Latin letters. The second line contains a non-empty string u, consisting of lowercase Latin letters. The lengths of both strings are in the range from 1 to 2000, inclusive.
Output
Print the only integer — the minimum number of changes that Dr. Moriarty has to make with the string that you choose.
Examples
Input
aaaaa
aaa
Output
0
Input
abcabc
bcd
Output
1
Input
abcdef
klmnopq
Output
7
Note
In the first sample Moriarty can take any substring of length 3, and it will be equal to the required message u, so Moriarty won't have to make any changes.
In the second sample you should take a substring consisting of characters from second to fourth ("bca") or from fifth to sixth ("bc"). Then you will only have to make one change: to change or to add the last character.
In the third sample the initial string s doesn't contain any character that the message should contain, so, whatever string you choose, you will have to make at least 7 changes to obtain the required message.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
double eps = 1e-9;
const int INF = 1e9 + 7;
const int MAXN = int(3e5 + 7);
int n, m, dp[2007][2007], ans;
string second, t;
int main() {
cin >> second >> t;
n = second.size(), m = t.size();
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (second[i] == t[j]) {
if (i == 0 || j == 0)
dp[i][j]++;
else
dp[i][j] = dp[i - 1][j - 1] + 1;
} else {
if (i == 0 || j == 0)
dp[i][j] = 0;
else
dp[i][j] = dp[i - 1][j - 1];
}
ans = max(ans, dp[i][j]);
}
}
cout << m - ans;
return 0;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
Dolphin resides in two-dimensional Cartesian plane, with the positive x-axis pointing right and the positive y-axis pointing up.
Currently, he is located at the point (sx,sy). In each second, he can move up, down, left or right by a distance of 1.
Here, both the x- and y-coordinates before and after each movement must be integers.
He will first visit the point (tx,ty) where sx < tx and sy < ty, then go back to the point (sx,sy), then visit the point (tx,ty) again, and lastly go back to the point (sx,sy).
Here, during the whole travel, he is not allowed to pass through the same point more than once, except the points (sx,sy) and (tx,ty).
Under this condition, find a shortest path for him.
Constraints
* -1000 ≤ sx < tx ≤ 1000
* -1000 ≤ sy < ty ≤ 1000
* sx,sy,tx and ty are integers.
Input
The input is given from Standard Input in the following format:
sx sy tx ty
Output
Print a string S that represents a shortest path for Dolphin.
The i-th character in S should correspond to his i-th movement.
The directions of the movements should be indicated by the following characters:
* `U`: Up
* `D`: Down
* `L`: Left
* `R`: Right
If there exist multiple shortest paths under the condition, print any of them.
Examples
Input
0 0 1 2
Output
UURDDLLUUURRDRDDDLLU
Input
-2 -2 1 1
Output
UURRURRDDDLLDLLULUUURRURRDDDLLDL
### Response
```cpp
#include <bits/stdc++.h>
#include <string>
using namespace std;
int main ()
{
int sx, sy, tx, ty;
cin >> sx >> sy >> tx >> ty;
map<int, int> memZahyo;
int dx = tx - sx;
int dy = ty - sy;
cout << string(dy, 'U') << string(dx, 'R');
cout << string(dy, 'D') << string(dx, 'L');
cout << 'L' << string(dy + 1, 'U') << string(dx + 1, 'R') << 'D';
cout << 'R' << string(dy + 1, 'D') << string(dx + 1, 'L') << 'U';
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
Polycarp has decided to decorate his room because the New Year is soon. One of the main decorations that Polycarp will install is the garland he is going to solder himself.
Simple garlands consisting of several lamps connected by one wire are too boring for Polycarp. He is going to solder a garland consisting of n lamps and n - 1 wires. Exactly one lamp will be connected to power grid, and power will be transmitted from it to other lamps by the wires. Each wire connectes exactly two lamps; one lamp is called the main lamp for this wire (the one that gets power from some other wire and transmits it to this wire), the other one is called the auxiliary lamp (the one that gets power from this wire). Obviously, each lamp has at most one wire that brings power to it (and this lamp is the auxiliary lamp for this wire, and the main lamp for all other wires connected directly to it).
Each lamp has a brightness value associated with it, the i-th lamp has brightness 2^i. We define the importance of the wire as the sum of brightness values over all lamps that become disconnected from the grid if the wire is cut (and all other wires are still working).
Polycarp has drawn the scheme of the garland he wants to make (the scheme depicts all n lamp and n - 1 wires, and the lamp that will be connected directly to the grid is marked; the wires are placed in such a way that the power can be transmitted to each lamp). After that, Polycarp calculated the importance of each wire, enumerated them from 1 to n - 1 in descending order of their importance, and then wrote the index of the main lamp for each wire (in the order from the first wire to the last one).
The following day Polycarp bought all required components of the garland and decided to solder it — but he could not find the scheme. Fortunately, Polycarp found the list of indices of main lamps for all wires. Can you help him restore the original scheme?
Input
The first line contains one integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of lamps.
The second line contains n - 1 integers a_1, a_2, ..., a_{n - 1} (1 ≤ a_i ≤ n), where a_i is the index of the main lamp for the i-th wire (wires are numbered in descending order of importance).
Output
If it is impossible to restore the original scheme, print one integer -1.
Otherwise print the scheme as follows. In the first line, print one integer k (1 ≤ k ≤ n) — the index of the lamp that is connected to the power grid. Then print n - 1 lines, each containing two integers x_i and y_i (1 ≤ x_i, y_i ≤ n, x_i ≠ y_i) — the indices of the lamps connected by some wire. The descriptions of the wires (and the lamps connected by a wire) can be printed in any order. The printed description must correspond to a scheme of a garland such that Polycarp could have written the list a_1, a_2, ..., a_{n - 1} from it. If there are multiple such schemes, output any of them.
Example
Input
6
3 6 3 1 5
Output
3
6 3
6 5
1 3
1 4
5 2
Note
The scheme for the first example (R denotes the lamp connected to the grid, the numbers on wires are their importance values):
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.precision(10);
cout << fixed;
int n;
cin >> n;
set<int> st;
for (int i = 1; i <= n; i++) st.insert(i);
vector<int> a(n - 1), cnt(n + 1);
for (int i = 0; i < n - 1; i++) {
cin >> a[i];
cnt[a[i]]++;
st.erase(a[i]);
}
vector<pair<int, int>> edges;
for (int i = n - 2; i >= 0; i--) {
int u = a[i];
if (st.empty()) {
cout << -1 << '\n';
return 0;
}
int v = *st.begin();
st.erase(st.begin());
cnt[u]--;
if (!cnt[u]) st.insert(u);
edges.push_back({u, v});
}
cout << a[0] << '\n';
reverse(edges.begin(), edges.end());
for (pair<int, int> i : edges) cout << i.first << ' ' << i.second << '\n';
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
Given is an integer N. Find the number of positive integers less than or equal to N that have an odd number of digits (in base ten without leading zeros).
Constraints
* 1 \leq N \leq 10^5
Input
Input is given from Standard Input in the following format:
N
Output
Print the number of positive integers less than or equal to N that have an odd number of digits.
Examples
Input
11
Output
9
Input
136
Output
46
Input
100000
Output
90909
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main()
{
int n,c=0;
cin>>n;
for(int i=1;i<=n;++i){
c+=(to_string(i).size()%2);
}
cout<<c<<endl;
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
Taro and Hanako decided to play hit-and-blow. The hit-and-blow rules are as follows.
* Separated into questioners and respondents.
* The questioner decides a 4-digit number (correct answer) that does not include duplicate numbers.
* Respondents guess the 4-digit number (answer).
* For the answer, the questioner gives a hint by the number of hits and blows.
* Comparing the answer and the correct answer, the fact that both the number and the digit position are the same is called a hit, and the fact that only the number is the same but the digit position is different is called a blow. For example, if the correct answer is 1234 and the answer is 1354, the questioner gives the hint "2 hits, 1 blow" and repeats until the correct answer.
* The questioner and the respondent take turns playing the game, and the one who guesses the correct answer with fewer answers wins.
Taro and Hanako seem to find it a little annoying to judge the number of hits and the number of blows each time. For those two, let's create a program that instantly shows the number of hits and the number of blows.
Create a program that inputs the correct answer r and the answer a and outputs the number of hits and the number of blows. r and a are a sequence of four numbers, 0 to 9, respectively.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by two lines of zeros. For each dataset, r and a are given on one line, separated by blanks.
The number of datasets does not exceed 12000.
Output
Outputs the number of hits and the number of blows on one line for each input dataset.
Example
Input
1234 5678
1234 1354
1234 1234
1230 1023
0123 1234
0 0
Output
0 0
2 1
4 0
1 3
0 3
### Response
```cpp
#include <iostream>
#include <cstdlib>
using namespace std;
int main()
{
char r[5], a[5];
cin >> r >> a;
while (atoi(r) != 0 || atoi(a) != 0) {
int h = 0, b = 0;
for (int i = 0; i < 4; i++) {
for(int j = 0; j < 4; j++)
if (r[i] == a[j]) {
if (i == j)
h++;
else
b++;
}
}
cout << h << " " << b << endl;
cin >> r >> a;
}
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
Luba has to do n chores today. i-th chore takes ai units of time to complete. It is guaranteed that for every <image> the condition ai ≥ ai - 1 is met, so the sequence is sorted.
Also Luba can work really hard on some chores. She can choose not more than k any chores and do each of them in x units of time instead of ai (<image>).
Luba is very responsible, so she has to do all n chores, and now she wants to know the minimum time she needs to do everything. Luba cannot do two chores simultaneously.
Input
The first line contains three integers n, k, x (1 ≤ k ≤ n ≤ 100, 1 ≤ x ≤ 99) — the number of chores Luba has to do, the number of chores she can do in x units of time, and the number x itself.
The second line contains n integer numbers ai (2 ≤ ai ≤ 100) — the time Luba has to spend to do i-th chore.
It is guaranteed that <image>, and for each <image> ai ≥ ai - 1.
Output
Print one number — minimum time Luba needs to do all n chores.
Examples
Input
4 2 2
3 6 7 10
Output
13
Input
5 2 1
100 100 100 100 100
Output
302
Note
In the first example the best option would be to do the third and the fourth chore, spending x = 2 time on each instead of a3 and a4, respectively. Then the answer is 3 + 6 + 2 + 2 = 13.
In the second example Luba can choose any two chores to spend x time on them instead of ai. So the answer is 100·3 + 2·1 = 302.
### Response
```cpp
#include <bits/stdc++.h>
int main() {
int a[100], b[100], c, d, e, i, j, k = 0, m, n, o;
scanf("%d %d %d", &c, &d, &e);
for (i = 0; i < c; i++) {
scanf("%d", &a[i]);
}
for (i = 0; i < c; i++) {
for (j = 1; j < c; j++) {
if (a[j - 1] > a[j]) {
o = a[j - 1];
a[j - 1] = a[j];
a[j] = o;
}
}
}
m = c - d;
for (j = 0; j < m; j++) {
k = k + a[j];
}
n = k + d * e;
printf("%d\n", n);
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
While creating high loaded systems one should pay a special attention to caching. This problem will be about one of the most popular caching algorithms called LRU (Least Recently Used).
Suppose the cache may store no more than k objects. At the beginning of the workflow the cache is empty. When some object is queried we check if it is present in the cache and move it here if it's not. If there are more than k objects in the cache after this, the least recently used one should be removed. In other words, we remove the object that has the smallest time of the last query.
Consider there are n videos being stored on the server, all of the same size. Cache can store no more than k videos and caching algorithm described above is applied. We know that any time a user enters the server he pick the video i with probability pi. The choice of the video is independent to any events before.
The goal of this problem is to count for each of the videos the probability it will be present in the cache after 10100 queries.
Input
The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 20) — the number of videos and the size of the cache respectively. Next line contains n real numbers pi (0 ≤ pi ≤ 1), each of them is given with no more than two digits after decimal point.
It's guaranteed that the sum of all pi is equal to 1.
Output
Print n real numbers, the i-th of them should be equal to the probability that the i-th video will be present in the cache after 10100 queries. You answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct, if <image>.
Examples
Input
3 1
0.3 0.2 0.5
Output
0.3 0.2 0.5
Input
2 1
0.0 1.0
Output
0.0 1.0
Input
3 2
0.3 0.2 0.5
Output
0.675 0.4857142857142857 0.8392857142857143
Input
3 3
0.2 0.3 0.5
Output
1.0 1.0 1.0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const int INF = 1000000000;
const int MAX = 22;
double P[MAX];
double D[1 << MAX];
int C[1 << MAX];
double R[MAX];
int main() {
int n, m;
cin >> n >> m;
m = min(m, n);
for (int i = (0); i < (n); ++i) {
cin >> P[i];
}
for (int i = (1); i < (1 << n); ++i) {
C[i] = C[i >> 1] + (i & 1);
}
D[0] = 1;
for (int i = (0); i < (1 << n); ++i) {
if (C[i] >= m) continue;
double s = 0;
for (int j = (0); j < (n); ++j) {
if ((i & (1 << j)) == 0) s += P[j];
}
if (s != 0) {
for (int j = (0); j < (n); ++j) {
if ((i & (1 << j)) == 0) {
D[i ^ (1 << j)] += D[i] * P[j] / s;
R[j] += D[i] * P[j] / s;
}
}
}
}
for (int i = (0); i < (n); ++i) {
printf("%.9f ", R[i]);
}
return 0;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
Roman is a young mathematician, very famous in Uzhland. Unfortunately, Sereja doesn't think so. To make Sereja change his mind, Roman is ready to solve any mathematical problem. After some thought, Sereja asked Roma to find, how many numbers are close to number n, modulo m.
Number x is considered close to number n modulo m, if:
* it can be obtained by rearranging the digits of number n,
* it doesn't have any leading zeroes,
* the remainder after dividing number x by m equals 0.
Roman is a good mathematician, but the number of such numbers is too huge for him. So he asks you to help him.
Input
The first line contains two integers: n (1 ≤ n < 1018) and m (1 ≤ m ≤ 100).
Output
In a single line print a single integer — the number of numbers close to number n modulo m.
Examples
Input
104 2
Output
3
Input
223 4
Output
1
Input
7067678 8
Output
47
Note
In the first sample the required numbers are: 104, 140, 410.
In the second sample the required number is 232.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int siz;
long long f[(1 << 18)][105];
bool chk[20];
int getbit(int mask, int k) { return ((mask >> (k - 1)) & 1); }
int cnt(int mask) {
int tmp = 0;
for (int i = 1; i <= siz; i++)
if (getbit(mask, i)) tmp++;
return tmp;
}
int main() {
string s;
int m;
cin >> s >> m;
siz = s.size();
f[0][0] = 1;
for (int i = 0; i < (1 << siz) - 1; i++) {
int num = cnt(i);
for (int k = 0; k < m; k++) {
if (!f[i][k]) continue;
memset(chk, 0, sizeof(chk));
for (int j = 1; j <= siz; j++)
if (getbit(i, j) == 0) {
if ((s[j - 1] == '0' && num == 0) || chk[s[j - 1] - '0']) continue;
f[i + (1 << (j - 1))][(10 * k + (s[j - 1] - '0')) % m] += f[i][k];
chk[s[j - 1] - '0'] = 1;
}
}
}
cout << f[(1 << siz) - 1][0] << endl;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
There are n sharks who grow flowers for Wet Shark. They are all sitting around the table, such that sharks i and i + 1 are neighbours for all i from 1 to n - 1. Sharks n and 1 are neighbours too.
Each shark will grow some number of flowers si. For i-th shark value si is random integer equiprobably chosen in range from li to ri. Wet Shark has it's favourite prime number p, and he really likes it! If for any pair of neighbouring sharks i and j the product si·sj is divisible by p, then Wet Shark becomes happy and gives 1000 dollars to each of these sharks.
At the end of the day sharks sum all the money Wet Shark granted to them. Find the expectation of this value.
Input
The first line of the input contains two space-separated integers n and p (3 ≤ n ≤ 100 000, 2 ≤ p ≤ 109) — the number of sharks and Wet Shark's favourite prime number. It is guaranteed that p is prime.
The i-th of the following n lines contains information about i-th shark — two space-separated integers li and ri (1 ≤ li ≤ ri ≤ 109), the range of flowers shark i can produce. Remember that si is chosen equiprobably among all integers from li to ri, inclusive.
Output
Print a single real number — the expected number of dollars that the sharks receive in total. You answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct, if <image>.
Examples
Input
3 2
1 2
420 421
420420 420421
Output
4500.0
Input
3 5
1 4
2 3
11 14
Output
0.0
Note
A prime number is a positive integer number that is divisible only by 1 and itself. 1 is not considered to be prime.
Consider the first sample. First shark grows some number of flowers from 1 to 2, second sharks grows from 420 to 421 flowers and third from 420420 to 420421. There are eight cases for the quantities of flowers (s0, s1, s2) each shark grows:
1. (1, 420, 420420): note that s0·s1 = 420, s1·s2 = 176576400, and s2·s0 = 420420. For each pair, 1000 dollars will be awarded to each shark. Therefore, each shark will be awarded 2000 dollars, for a total of 6000 dollars.
2. (1, 420, 420421): now, the product s2·s0 is not divisible by 2. Therefore, sharks s0 and s2 will receive 1000 dollars, while shark s1 will receive 2000. The total is 4000.
3. (1, 421, 420420): total is 4000
4. (1, 421, 420421): total is 0.
5. (2, 420, 420420): total is 6000.
6. (2, 420, 420421): total is 6000.
7. (2, 421, 420420): total is 6000.
8. (2, 421, 420421): total is 4000.
The expected value is <image>.
In the second sample, no combination of quantities will garner the sharks any money.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long int n, p;
const long long int N = 1e5;
long long int a[N];
long long int l[N], r[N];
void input() {
scanf("%I64d %I64d", &n, &p);
for (long long int i = 0; i < n; i++) scanf("%I64d %I64d", &l[i], &r[i]);
}
long long int good(long long int left, long long int right) {
long long int ans = -(left - 1) / p + right / p;
return ans;
}
long double cal(long long int i, long long int j) {
long long int s1 = good(l[i], r[i]);
long long int s2 = good(l[j], r[j]);
long long int to1 = r[i] - l[i] + 1;
long long int to2 = r[j] - l[j] + 1;
s1 = to1 - s1;
s2 = to2 - s2;
long double ans =
(long double)(s2 * s1 + 0.00) / (long double)(to1 * to2 + 0.00);
ans = 1.00 - ans;
return ans;
}
void solve() {
long double ans = 0.00;
for (long long int i = 0; i < n; i++) {
long long int j = (i + 1) % n;
ans += cal(i, j) * 2000.00;
}
cout << fixed << setprecision(10) << ans << endl;
}
int main() {
input();
solve();
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Mike has discovered a new way to encode permutations. If he has a permutation P = [p1, p2, ..., pn], he will encode it in the following way:
Denote by A = [a1, a2, ..., an] a sequence of length n which will represent the code of the permutation. For each i from 1 to n sequentially, he will choose the smallest unmarked j (1 ≤ j ≤ n) such that pi < pj and will assign to ai the number j (in other words he performs ai = j) and will mark j. If there is no such j, he'll assign to ai the number - 1 (he performs ai = - 1).
Mike forgot his original permutation but he remembers its code. Your task is simple: find any permutation such that its code is the same as the code of Mike's original permutation.
You may assume that there will always be at least one valid permutation.
Input
The first line contains single integer n (1 ≤ n ≤ 500 000) — length of permutation.
The second line contains n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ n or ai = - 1) — the code of Mike's permutation.
You may assume that all positive values from A are different.
Output
In first and only line print n numbers p1, p2, ..., pn (1 ≤ pi ≤ n) — a permutation P which has the same code as the given one. Note that numbers in permutation are distinct.
Examples
Input
6
2 -1 1 5 -1 4
Output
2 6 1 4 5 3
Input
8
2 -1 4 -1 6 -1 8 -1
Output
1 8 2 7 3 6 4 5
Note
For the permutation from the first example:
i = 1, the smallest j is 2 because p2 = 6 > p1 = 2.
i = 2, there is no j because p2 = 6 is the greatest element in the permutation.
i = 3, the smallest j is 1 because p1 = 2 > p3 = 1.
i = 4, the smallest j is 5 (2 was already marked) because p5 = 5 > p4 = 4.
i = 5, there is no j because 2 is already marked.
i = 6, the smallest j is 4 because p4 = 4 > p6 = 3.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 500005;
int n, a[N], b[N];
struct TNode {
pair<int, int> v;
int l, r;
} t[N << 2];
inline int lc(int pos) { return pos << 1; }
inline int rc(int pos) { return pos << 1 | 1; }
inline void pushup(int pos) { t[pos].v = max(t[lc(pos)].v, t[rc(pos)].v); }
void build(int pos, int l, int r) {
t[pos].l = l;
t[pos].r = r;
if (l == r) {
t[pos].v = {b[l], l};
return;
}
int mid = (l + r) >> 1;
build(lc(pos), l, mid);
build(rc(pos), mid + 1, r);
pushup(pos);
}
pair<int, int> query(int pos, int l, int r) {
if (t[pos].l == l && t[pos].r == r) return t[pos].v;
int mid = (t[pos].l + t[pos].r) >> 1;
if (r <= mid)
return query(lc(pos), l, r);
else if (l > mid)
return query(rc(pos), l, r);
else
return max(query(lc(pos), l, mid), query(rc(pos), mid + 1, r));
}
void del(int pos, int p) {
if (t[pos].l == t[pos].r) {
t[pos].v = {0, t[pos].l};
return;
}
int mid = (t[pos].l + t[pos].r) >> 1;
if (p <= mid)
del(lc(pos), p);
else
del(rc(pos), p);
pushup(pos);
}
int q[N], m, p[N];
bool vis[N];
void dfs(int pos) {
vis[pos] = 1;
del(1, pos);
if (b[pos] != n + 1 && !vis[b[pos]]) dfs(b[pos]);
if (a[pos] > 1)
while (1) {
auto ret = query(1, 1, a[pos] - 1);
if (ret.first > pos)
dfs(ret.second), assert(ret.second);
else
break;
}
q[++m] = pos;
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] != -1)
b[a[i]] = i;
else
a[i] = n + 1;
}
for (int i = 1; i <= n; i++)
if (!b[i]) b[i] = n + 1;
build(1, 1, n);
for (int i = 1; i <= n; i++)
if (!vis[i]) dfs(i);
m = 0;
for (int i = 1; i <= n; i++) p[q[i]] = ++m;
for (int i = 1; i <= n; i++) cout << p[i] << ' ';
return 0;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
Recently Monocarp got a job. His working day lasts exactly m minutes. During work, Monocarp wants to drink coffee at certain moments: there are n minutes a_1, a_2, ..., a_n, when he is able and willing to take a coffee break (for the sake of simplicity let's consider that each coffee break lasts exactly one minute).
However, Monocarp's boss doesn't like when Monocarp takes his coffee breaks too often. So for the given coffee break that is going to be on minute a_i, Monocarp must choose the day in which he will drink coffee during the said minute, so that every day at least d minutes pass between any two coffee breaks. Monocarp also wants to take these n coffee breaks in a minimum possible number of working days (he doesn't count days when he is not at work, and he doesn't take coffee breaks on such days). Take into account that more than d minutes pass between the end of any working day and the start of the following working day.
For each of the n given minutes determine the day, during which Monocarp should take a coffee break in this minute. You have to minimize the number of days spent.
Input
The first line contains three integers n, m, d (1 ≤ n ≤ 2⋅10^{5}, n ≤ m ≤ 10^{9}, 1 ≤ d ≤ m) — the number of coffee breaks Monocarp wants to have, the length of each working day, and the minimum number of minutes between any two consecutive coffee breaks.
The second line contains n distinct integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ m), where a_i is some minute when Monocarp wants to have a coffee break.
Output
In the first line, write the minimum number of days required to make a coffee break in each of the n given minutes.
In the second line, print n space separated integers. The i-th of integers should be the index of the day during which Monocarp should have a coffee break at minute a_i. Days are numbered from 1. If there are multiple optimal solutions, you may print any of them.
Examples
Input
4 5 3
3 5 1 2
Output
3
3 1 1 2
Input
10 10 1
10 5 7 4 6 3 2 1 9 8
Output
2
2 1 1 2 2 1 2 1 1 2
Note
In the first example, Monocarp can take two coffee breaks during the first day (during minutes 1 and 5, 3 minutes will pass between these breaks). One break during the second day (at minute 2), and one break during the third day (at minute 3).
In the second example, Monocarp can determine the day of the break as follows: if the minute when he wants to take a break is odd, then this break is on the first day, if it is even, then this break is on the second day.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
void solve() {
int n, m, d;
cin >> n >> m >> d;
int a[n];
set<pair<int, int>> s;
for (int i = 0; i < n; i++) {
cin >> a[i];
s.insert({a[i], i});
}
vector<int> ans(n, -1);
int k = 0;
while (s.size()) {
k++;
int pos = s.begin()->second;
ans[pos] = k;
s.erase(s.begin());
while (1) {
auto it = s.lower_bound({a[pos] + 1 + d, 0});
if (it == s.end()) break;
pos = it->second;
s.erase(it);
ans[pos] = k;
}
}
cout << k << "\n";
for (int i = 0; i < n; i++) cout << ans[i] << " ";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
while (t--) {
solve();
}
return 0;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
Kefa wants to celebrate his first big salary by going to restaurant. However, he needs company.
Kefa has n friends, each friend will agree to go to the restaurant if Kefa asks. Each friend is characterized by the amount of money he has and the friendship factor in respect to Kefa. The parrot doesn't want any friend to feel poor compared to somebody else in the company (Kefa doesn't count). A friend feels poor if in the company there is someone who has at least d units of money more than he does. Also, Kefa wants the total friendship factor of the members of the company to be maximum. Help him invite an optimal company!
Input
The first line of the input contains two space-separated integers, n and d (1 ≤ n ≤ 105, <image>) — the number of Kefa's friends and the minimum difference between the amount of money in order to feel poor, respectively.
Next n lines contain the descriptions of Kefa's friends, the (i + 1)-th line contains the description of the i-th friend of type mi, si (0 ≤ mi, si ≤ 109) — the amount of money and the friendship factor, respectively.
Output
Print the maximum total friendship factir that can be reached.
Examples
Input
4 5
75 5
0 100
150 20
75 1
Output
100
Input
5 100
0 7
11 32
99 10
46 8
87 54
Output
111
Note
In the first sample test the most profitable strategy is to form a company from only the second friend. At all other variants the total degree of friendship will be worse.
In the second sample test we can take all the friends.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 5;
vector<long long> v;
long long n, d;
long long sum = 0;
long long A[N];
long long f[N];
vector<pair<long long, long long>> vv;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n;
cin >> d;
long long i;
for (i = 0; i < n; i++) {
long long a, b;
cin >> a >> b;
vv.push_back({a, b});
}
sort(vv.begin(), vv.end());
for (i = 0; i < n; i++) {
sum += vv[i].second;
A[i] = sum;
f[i] = vv[i].second;
v.push_back(vv[i].first);
}
long long best = INT_MIN;
for (i = 0; i < n; i++) {
long long xx = (v[i] - d);
long long yy = (v[i] + d);
auto p = upper_bound(v.begin(), v.end(), xx);
long long xxx = p - v.begin();
long long cur1 = A[i] - A[xxx] + f[xxx];
auto q = lower_bound(v.begin(), v.end(), yy);
long long yyy = q - v.begin();
yyy--;
long long cur2 = A[yyy] - A[i] + f[i];
long long cur = max(cur1, cur2);
if (cur > best) {
best = cur;
}
}
cout << best << "\n";
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
Sereja has an array a, consisting of n integers a1, a2, ..., an. The boy cannot sit and do nothing, he decided to study an array. Sereja took a piece of paper and wrote out m integers l1, l2, ..., lm (1 ≤ li ≤ n). For each number li he wants to know how many distinct numbers are staying on the positions li, li + 1, ..., n. Formally, he want to find the number of distinct numbers among ali, ali + 1, ..., an.?
Sereja wrote out the necessary array elements but the array was so large and the boy was so pressed for time. Help him, find the answer for the described question for each li.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 105). The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 105) — the array elements.
Next m lines contain integers l1, l2, ..., lm. The i-th line contains integer li (1 ≤ li ≤ n).
Output
Print m lines — on the i-th line print the answer to the number li.
Examples
Input
10 10
1 2 3 4 1 2 3 4 100000 99999
1
2
3
4
5
6
7
8
9
10
Output
6
6
6
6
6
5
4
3
2
1
### Response
```cpp
#include <bits/stdc++.h>
int a[100005], b[100005], c[100005];
int main() {
int n, q, i, k, ans;
while (~scanf("%d %d", &n, &q)) {
memset(b, 0, sizeof(b));
memset(c, 0, sizeof(c));
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
c[a[n - 1]] = 1;
b[n - 1] = 1;
for (i = n - 2; i >= 0; i--) {
if (c[a[i]] != 1) {
c[a[i]] = 1;
b[i] = b[i + 1] + 1;
} else {
b[i] = b[i + 1];
}
}
for (i = 0; i < q; i++) {
scanf("%d", &k);
printf("%d\n", b[k - 1]);
}
}
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
There are n cows playing poker at a table. For the current betting phase, each player's status is either "ALLIN", "IN", or "FOLDED", and does not change throughout the phase. To increase the suspense, a player whose current status is not "FOLDED" may show his/her hand to the table. However, so as not to affect any betting decisions, he/she may only do so if all other players have a status of either "ALLIN" or "FOLDED". The player's own status may be either "ALLIN" or "IN".
Find the number of cows that can currently show their hands without affecting any betting decisions.
Input
The first line contains a single integer, n (2 ≤ n ≤ 2·105). The second line contains n characters, each either "A", "I", or "F". The i-th character is "A" if the i-th player's status is "ALLIN", "I" if the i-th player's status is "IN", or "F" if the i-th player's status is "FOLDED".
Output
The first line should contain a single integer denoting the number of players that can currently show their hands.
Examples
Input
6
AFFAAA
Output
4
Input
3
AFI
Output
1
Note
In the first sample, cows 1, 4, 5, and 6 can show their hands. In the second sample, only cow 3 can show her hand.
### Response
```cpp
#include <bits/stdc++.h>
int main() {
long j, n, I, A, F;
char aux;
scanf("%li", &n);
scanf("%c", &aux);
A = I = F = 0;
for (j = 1; j <= n; j++) {
scanf("%c", &aux);
if (aux == 'A') {
A++;
}
if (aux == 'F') {
F++;
}
if (aux == 'I') {
I++;
}
}
if (I == 1) {
printf("1\n");
} else {
if (I > 1) {
printf("0\n");
} else {
printf("%ld\n", A);
}
}
return 0;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
A wise king declared a new calendar. "Tomorrow shall be the first day of the calendar, that is, the day 1 of the month 1 of the year 1. Each year consists of 10 months, from month 1 through month 10, and starts from a big month. A common year shall start with a big month, followed by small months and big months one after another. Therefore the first month is a big month, the second month is a small month, the third a big month, ..., and the 10th and last month a small one. A big month consists of 20 days and a small month consists of 19 days. However years which are multiples of three, that are year 3, year 6, year 9, and so on, shall consist of 10 big months and no small month."
Many years have passed since the calendar started to be used. For celebration of the millennium day (the year 1000, month 1, day 1), a royal lottery is going to be organized to send gifts to those who have lived as many days as the number chosen by the lottery. Write a program that helps people calculate the number of days since their birthdate to the millennium day.
Input
The input is formatted as follows.
> n
> Y1 M1 D1
> Y2 M2 D2
> ...
> Yn Mn Dn
Here, the first line gives the number of datasets as a positive integer n, which is less than or equal to 100. It is followed by n datasets. Each dataset is formatted in a line and gives three positive integers, Yi (< 1000), Mi (≤ 10), and Di (≤ 20), that correspond to the year, month and day, respectively, of a person's birthdate in the king's calendar. These three numbers are separated by a space.
Output
For the birthdate specified in each dataset, print in a line the number of days from the birthdate, inclusive, to the millennium day, exclusive. Output lines should not contain any character other than this number.
Sample Input
8
1 1 1
344 3 1
696 5 1
182 9 5
998 8 7
344 2 19
696 4 19
999 10 20
Output for the Sample Input
196470
128976
59710
160715
252
128977
59712
1
Example
Input
8
1 1 1
344 3 1
696 5 1
182 9 5
998 8 7
344 2 19
696 4 19
999 10 20
Output
196470
128976
59710
160715
252
128977
59712
1
### Response
```cpp
#include <iostream>
using namespace std;
int main(){
int n;
cin >> n;
for (int i = 0; i < n; i++){
int Y, M, D;
cin >> Y >> M >> D;
int offset = (10 - M + 1) * 20 - (D - 1);
if (Y % 3 != 0){
offset -= (12 - M) / 2;
}
Y++;
int uruutime = (1002 - Y) / 3;
int ans = offset + 195 * (1000 - Y) + uruutime * 5;
cout << ans << endl;
}
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
You are given a bipartite graph: the first part of this graph contains n_1 vertices, the second part contains n_2 vertices, and there are m edges. The graph can contain multiple edges.
Initially, each edge is colorless. For each edge, you may either leave it uncolored (it is free), paint it red (it costs r coins) or paint it blue (it costs b coins). No edge can be painted red and blue simultaneously.
There are three types of vertices in this graph — colorless, red and blue. Colored vertices impose additional constraints on edges' colours:
* for each red vertex, the number of red edges indicent to it should be strictly greater than the number of blue edges incident to it;
* for each blue vertex, the number of blue edges indicent to it should be strictly greater than the number of red edges incident to it.
Colorless vertices impose no additional constraints.
Your goal is to paint some (possibly none) edges so that all constraints are met, and among all ways to do so, you should choose the one with minimum total cost.
Input
The first line contains five integers n_1, n_2, m, r and b (1 ≤ n_1, n_2, m, r, b ≤ 200) — the number of vertices in the first part, the number of vertices in the second part, the number of edges, the amount of coins you have to pay to paint an edge red, and the amount of coins you have to pay to paint an edge blue, respectively.
The second line contains one string consisting of n_1 characters. Each character is either U, R or B. If the i-th character is U, then the i-th vertex of the first part is uncolored; R corresponds to a red vertex, and B corresponds to a blue vertex.
The third line contains one string consisting of n_2 characters. Each character is either U, R or B. This string represents the colors of vertices of the second part in the same way.
Then m lines follow, the i-th line contains two integers u_i and v_i (1 ≤ u_i ≤ n_1, 1 ≤ v_i ≤ n_2) denoting an edge connecting the vertex u_i from the first part and the vertex v_i from the second part.
The graph may contain multiple edges.
Output
If there is no coloring that meets all the constraints, print one integer -1.
Otherwise, print an integer c denoting the total cost of coloring, and a string consisting of m characters. The i-th character should be U if the i-th edge should be left uncolored, R if the i-th edge should be painted red, or B if the i-th edge should be painted blue. If there are multiple colorings with minimum possible cost, print any of them.
Examples
Input
3 2 6 10 15
RRB
UB
3 2
2 2
1 2
1 1
2 1
1 1
Output
35
BUURRU
Input
3 1 3 4 5
RRR
B
2 1
1 1
3 1
Output
-1
Input
3 1 3 4 5
URU
B
2 1
1 1
3 1
Output
14
RBB
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
namespace io {
template <class free>
inline void read(free&);
inline void read(char&);
template <class f1, class... f2>
inline void read(f1&, f2&...);
inline void read(char& c) {
while (c = getchar(), c == ' ' || c == '\n' || c == '\r')
;
}
template <class f1, class... f2>
inline void read(f1& x, f2&... y) {
read(x), read(y...);
}
template <class free>
inline void read(free& x) {
x ^= x;
register char c;
while (c = getchar(), c < '0' || c > '9')
;
while (c >= '0' && c <= '9')
x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
}
} // namespace io
using io::read;
struct point {
int next, to, w, w1;
} ar[4050];
bool is[4050];
int ps, pt, a1[4050], a2[4050], pre[4050];
int tot, a[4050], head[4050], art(1), fee;
int ps1, pt1, T[4050], flow[4050], dis[4050];
inline bool bfs();
inline void link(int, int, int, int);
int main() {
int n1, n2, m, r, b, ans(0);
read(n1, n2, m, r, b), tot = n1 + n2;
for (int i(1); i <= tot; ++i) {
char c;
switch (read(c), c) {
case 'U':
a[i] = -1;
break;
case 'R':
a[i] = 0;
break;
case 'B':
a[i] = 1;
break;
}
}
ps = ++tot, pt = ++tot;
for (int i(1); i <= n1; ++i) {
if (!~a[i]) {
link(ps, i, 0x3f3f3f3f, 0), link(i, pt, 0x3f3f3f3f, 0);
continue;
}
if (a[i])
--a1[i], ++a1[pt], link(i, pt, 0x3f3f3f3f, 0);
else
++a1[i], --a1[ps], link(ps, i, 0x3f3f3f3f, 0);
}
for (int i(n1 + 1); i <= n1 + n2; ++i) {
if (!~a[i]) {
link(ps, i, 0x3f3f3f3f, 0), link(i, pt, 0x3f3f3f3f, 0);
continue;
}
if (a[i])
++a1[i], --a1[ps], link(ps, i, 0x3f3f3f3f, 0);
else
--a1[i], ++a1[pt], link(i, pt, 0x3f3f3f3f, 0);
}
for (int i(1), u, v; i <= m; ++i)
read(u, v), link(u, v + n1, 1, r), a2[i] = art, link(v + n1, u, 1, b);
link(pt, ps, 0x3f3f3f3f, 0), ps1 = ++tot, pt1 = ++tot;
for (int i(1); i <= n1 + n2 + 2; ++i) {
if (!a1[i]) continue;
if (a1[i] > 0)
link(ps1, i, a1[i], 0);
else
link(i, pt1, -a1[i], 0);
}
while (bfs())
;
for (int i(head[ps1]); i; i = ar[i].next)
if (ar[i].w) return puts("-1"), 0;
printf("%d\n", fee);
for (int i(1); i <= m; ++i)
if (ar[a2[i]].w)
putchar('R');
else if (ar[a2[i] + 2].w)
putchar('B');
else
putchar('U');
return 0;
}
inline bool bfs() {
memset(dis, 0x3f, tot + 1 << 2);
int L(0), R(1);
dis[T[1] = ps1] = 0, flow[ps1] = 0x3f3f3f3f;
while (L++ ^ R)
for (int i(head[is[T[L = L ^ 4050 ? L : 0]] = 0, T[L]]), i1; i;
i = ar[i].next)
if (ar[i].w && dis[i1 = ar[i].to] > dis[T[L]] + ar[i].w1) {
dis[i1] = dis[T[L]] + ar[i].w1;
flow[i1] = min(flow[T[L]], ar[i].w), pre[i1] = i;
if (is[i1]) continue;
is[T[++R, R = R ^ 4050 ? R : 4050] = i1] = 1;
}
if (dis[pt1] >= 0x3f3f3f3f) return false;
for (int i(pt1); pre[i]; i = ar[pre[i] ^ 1].to)
ar[pre[i]].w -= flow[pt1], ar[pre[i] ^ 1].w += flow[pt1];
return fee += dis[pt1] * flow[pt1], true;
}
inline void link(int u, int v, int w, int w1) {
ar[++art] = {head[u], v, w, w1}, head[u] = art;
ar[++art] = {head[v], u, 0, -w1}, head[v] = art;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
We have a point A with coordinate x = n on OX-axis. We'd like to find an integer point B (also on OX-axis), such that the absolute difference between the distance from O to B and the distance from A to B is equal to k.
<image> The description of the first test case.
Since sometimes it's impossible to find such point B, we can, in one step, increase or decrease the coordinate of A by 1. What is the minimum number of steps we should do to make such point B exist?
Input
The first line contains one integer t (1 ≤ t ≤ 6000) — the number of test cases.
The only line of each test case contains two integers n and k (0 ≤ n, k ≤ 10^6) — the initial position of point A and desirable absolute difference.
Output
For each test case, print the minimum number of steps to make point B exist.
Example
Input
6
4 0
5 8
0 1000000
0 0
1 0
1000000 1000000
Output
0
3
1000000
0
1
0
Note
In the first test case (picture above), if we set the coordinate of B as 2 then the absolute difference will be equal to |(2 - 0) - (4 - 2)| = 0 and we don't have to move A. So the answer is 0.
In the second test case, we can increase the coordinate of A by 3 and set the coordinate of B as 0 or 8. The absolute difference will be equal to |8 - 0| = 8, so the answer is 3.
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
if (n == k) {
cout << 0 << "\n";
continue;
} else {
if ((n + k) % 2 == 0) {
if ((n + k) / 2 <= n) {
cout << 0 << "\n";
continue;
} else {
cout << k - n << "\n";
}
} else {
n++;
if ((n + k) / 2 <= n) {
cout << 1 << "\n";
continue;
} else {
cout << k - n + 1 << "\n";
}
}
}
}
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
There is a matrix A of size x × y filled with integers. For every <image>, <image> Ai, j = y(i - 1) + j. Obviously, every integer from [1..xy] occurs exactly once in this matrix.
You have traversed some path in this matrix. Your path can be described as a sequence of visited cells a1, a2, ..., an denoting that you started in the cell containing the number a1, then moved to the cell with the number a2, and so on.
From the cell located in i-th line and j-th column (we denote this cell as (i, j)) you can move into one of the following cells:
1. (i + 1, j) — only if i < x;
2. (i, j + 1) — only if j < y;
3. (i - 1, j) — only if i > 1;
4. (i, j - 1) — only if j > 1.
Notice that making a move requires you to go to an adjacent cell. It is not allowed to stay in the same cell. You don't know x and y exactly, but you have to find any possible values for these numbers such that you could start in the cell containing the integer a1, then move to the cell containing a2 (in one step), then move to the cell containing a3 (also in one step) and so on. Can you choose x and y so that they don't contradict with your sequence of moves?
Input
The first line contains one integer number n (1 ≤ n ≤ 200000) — the number of cells you visited on your path (if some cell is visited twice, then it's listed twice).
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109) — the integers in the cells on your path.
Output
If all possible values of x and y such that 1 ≤ x, y ≤ 109 contradict with the information about your path, print NO.
Otherwise, print YES in the first line, and in the second line print the values x and y such that your path was possible with such number of lines and columns in the matrix. Remember that they must be positive integers not exceeding 109.
Examples
Input
8
1 2 3 6 9 8 5 2
Output
YES
3 3
Input
6
1 2 1 2 5 3
Output
NO
Input
2
1 10
Output
YES
4 9
Note
The matrix and the path on it in the first test looks like this:
<image>
Also there exist multiple correct answers for both the first and the third examples.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long int Maxn3 = 1e3 + 10;
const long long int Maxn4 = 1e4 + 10;
const long long int Maxn5 = 1e5 + 10;
const long long int Maxn6 = 1e6 + 10;
const long long int Maxn7 = 1e7 + 10;
const long long int Maxn8 = 1e8 + 10;
const long long int Maxn9 = 1e9 + 10;
const long long int Maxn18 = 1e18 + 10;
const long long int Mod1 = 1e7 + 7;
const long long int Mod2 = 1e9 + 7;
const long long int LLMax = LLONG_MAX;
const long long int LLMin = LLONG_MIN;
const long long int INTMax = INT_MAX;
const long long int INTMin = INT_MIN;
long long int mn = LLMax, mx = LLMin;
const int MX = 2e5 + 100;
long long int c[MX];
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
long long int n, k = 0;
cin >> n;
for (long long int i = 0; i < n; i++) cin >> c[i];
bool m = 0;
for (long long int i = 1; i < n; i++) {
long long int p = abs(c[i] - c[i - 1]);
if (!p) return cout << "NO", 0;
if (p > 1) {
m = 1;
k = p;
break;
}
}
if (!m) {
cout << "YES" << '\n';
return cout << 1 << ' ' << 1000000000, 0;
}
for (long long int i = 1; i < n; i++) {
long long int p = abs(c[i] - c[i - 1]);
if (!p || (p != 1 and p != k) ||
(p == 1 and ((c[i] % k == 0 and c[i - 1] == c[i] + 1) ||
(c[i - 1] % k == 0 and c[i] == c[i - 1] + 1))))
return cout << "NO", 0;
}
cout << "YES" << endl;
cout << 1000000000 << ' ' << k;
return 0;
}
``` |
### Prompt
Develop a solution in CPP 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;
vector<int> ma[200005];
int p[200005];
long long yu;
void dfs(int pos, int fa, int now) {
p[pos] = 1;
yu += 1LL * now;
int sz = ma[pos].size();
for (int i = 0; i < sz; i++) {
int to = ma[pos][i];
if (to == fa) continue;
dfs(to, pos, 1 - now);
p[pos] += p[to];
}
}
int main() {
int n;
scanf("%d", &n);
yu = 0;
for (int i = 1; i < n; i++) {
int a, b;
scanf("%d%d", &a, &b);
ma[a].push_back(b);
ma[b].push_back(a);
}
dfs(1, -1, 0);
long long res = 0;
for (int i = 1; i <= n; i++) {
res += 1LL * p[i] * (n - p[i]);
}
res += yu * (n - yu);
printf("%lld\n", res / 2);
}
``` |
### Prompt
Generate a CPP solution to the following problem:
At Moscow Workshops ICPC team gets a balloon for each problem they solved first. Team MSU Red Panda got so many balloons that they didn't know how to spend them. So they came up with a problem with them.
There are several balloons, not more than 10^6 in total, each one is colored in one of k colors. We can perform the following operation: choose k-1 balloons such that they are of k-1 different colors, and recolor them all into remaining color. We can perform this operation any finite number of times (for example, we can only perform the operation if there are at least k-1 different colors among current balls).
How many different balloon configurations can we get? Only number of balloons of each color matters, configurations differing only by the order of balloons are counted as equal. As this number can be very large, output it modulo 998244353.
Input
The first line contains a single integer k (2 ≤ k ≤ 10^5) —the number of colors.
The second line contains k integers a_1, a_2, …, a_k (0 ≤ a_i) —initial configuration of balloons. a_i is number of balloons of color i. The total number of balloons doesn't exceed 10^6. In other words,
a_1 + a_2 + a_3 + … + a_k ≤ 10^6.
Output
Output number of possible configurations modulo 998244353.
Examples
Input
3
0 1 2
Output
3
Input
4
1 1 1 1
Output
5
Input
5
0 0 1 2 3
Output
1
Input
3
2 2 8
Output
31
Note
In the first example, there are 3 configurations we can get: [0, 1, 2], [2, 0, 1], [1, 2, 0].
In the second example, we can apply the operation not more than once, and possible configurations are: [1, 1, 1, 1], [0, 0, 0, 4], [0, 0, 4, 0], [0, 4, 0, 0], [4, 0, 0, 0].
In the third example, we can't apply any operations, so the only achievable configuration is the starting one.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10, mod = 998244353;
const long long inf = 1e18;
int a[maxn], n, cnt[maxn], fac[maxn], ifac[maxn];
int C(int n, int k) {
if (n < k) return 0;
return 1ll * fac[n] * ifac[k] % mod * ifac[n - k] % mod;
}
int solve(int k) {
int ls = 0, ans = 1;
for (int i = 0; i < k; i++) {
ls += cnt[i];
ans = (ans + C(i + n - ls, n - 1)) % mod;
}
return ans;
}
int Pow(int a, int b) {
int ans = 1;
for (; b; b >>= 1, a = 1ll * a * a % mod) {
if (b & 1) ans = 1ll * ans * a % mod;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
fac[0] = 1;
for (int i = 1; i < maxn; i++) fac[i] = 1ll * i * fac[i - 1] % mod;
ifac[maxn - 1] = Pow(fac[maxn - 1], mod - 2);
for (int i = maxn - 2; i >= 0; i--)
ifac[i] = 1ll * (i + 1) * ifac[i + 1] % mod;
int sm = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
sm += a[i] - (a[i] % n);
cnt[a[i]]++;
}
sm /= n;
sort(a, a + n);
for (int i = 0; i < n; i++) {
if (a[i] < i) {
return cout << solve(a[i]) << endl, 0;
}
}
memset(cnt, 0, sizeof cnt);
for (int i = 0; i < n; i++) {
cnt[a[i] % n]++;
}
int ans = 0;
for (int i = 0; i < n; i++) {
ans = (ans + C(sm + n - 1, n - 1)) % mod;
sm++;
sm -= cnt[i];
}
return cout << ans << endl, 0;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
Wilbur the pig really wants to be a beaver, so he decided today to pretend he is a beaver and bite at trees to cut them down.
There are n trees located at various positions on a line. Tree i is located at position xi. All the given positions of the trees are distinct.
The trees are equal, i.e. each tree has height h. Due to the wind, when a tree is cut down, it either falls left with probability p, or falls right with probability 1 - p. If a tree hits another tree while falling, that tree will fall in the same direction as the tree that hit it. A tree can hit another tree only if the distance between them is strictly less than h.
For example, imagine there are 4 trees located at positions 1, 3, 5 and 8, while h = 3 and the tree at position 1 falls right. It hits the tree at position 3 and it starts to fall too. In it's turn it hits the tree at position 5 and it also starts to fall. The distance between 8 and 5 is exactly 3, so the tree at position 8 will not fall.
As long as there are still trees standing, Wilbur will select either the leftmost standing tree with probability 0.5 or the rightmost standing tree with probability 0.5. Selected tree is then cut down. If there is only one tree remaining, Wilbur always selects it. As the ground is covered with grass, Wilbur wants to know the expected total length of the ground covered with fallen trees after he cuts them all down because he is concerned about his grass-eating cow friends. Please help Wilbur.
Input
The first line of the input contains two integers, n (1 ≤ n ≤ 2000) and h (1 ≤ h ≤ 108) and a real number p (0 ≤ p ≤ 1), given with no more than six decimal places.
The second line of the input contains n integers, x1, x2, ..., xn ( - 108 ≤ xi ≤ 108) in no particular order.
Output
Print a single real number — the expected total length of the ground covered by trees when they have all fallen down. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct, if <image>.
Examples
Input
2 2 0.500000
1 2
Output
3.250000000
Input
4 3 0.4
4 3 1 2
Output
6.631200000
Note
Consider the first example, we have 2 trees with height 2.
<image> There are 3 scenarios:
1. Both trees falls left. This can either happen with the right tree falling left first, which has <image> probability (also knocking down the left tree), or the left tree can fall left and then the right tree can fall left, which has <image> probability. Total probability is <image>.
2. Both trees fall right. This is analogous to (1), so the probability of this happening is <image>.
3. The left tree fall left and the right tree falls right. This is the only remaining scenario so it must have <image> probability.
Cases 1 and 2 lead to a total of 3 units of ground covered, while case 3 leads to a total of 4 units of ground covered. Thus, the expected value is <image>.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int ll[2005], lr[2005];
double f[2005][2005][2][2];
int a[2005];
int n, h;
double k;
double dfs(int l, int r, int al, int ar) {
if (l > r) return 0;
if (f[l][r][al][ar] != 0) return f[l][r][al][ar];
double s = 0;
s += k * 0.5 * (min(a[l] - a[l - 1] - al * h, h) + dfs(l + 1, r, 0, ar));
s +=
(1 - k) * 0.5 * (min(a[r + 1] - a[r] - ar * h, h) + dfs(l, r - 1, al, 0));
if (ll[r] <= l) {
s += k * 0.5 * (min(a[l] - a[l - 1] - h * al, h) + a[r] - a[l]);
} else
s += k * 0.5 * (dfs(l, ll[r] - 1, al, 1) + a[r] - a[ll[r]] + h);
if (lr[l] >= r) {
s += (1 - k) * 0.5 * (min(a[r + 1] - a[r] - h * ar, h) + a[r] - a[l]);
} else
s += (1 - k) * 0.5 * (dfs(lr[l] + 1, r, 1, ar) + a[lr[l]] - a[l] + h);
return f[l][r][al][ar] = s;
}
int main() {
cin >> n >> h >> k;
a[0] = -9999999999;
a[n + 1] = 9999999999;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
memset(f, 0, sizeof(f));
sort(a + 1, a + 1 + n);
ll[1] = 1;
lr[n] = n;
for (int i = 2; i <= n; i++) {
if (a[i] - h < a[i - 1]) {
ll[i] = ll[i - 1];
} else
ll[i] = i;
}
for (int i = n - 1; i >= 1; i--) {
if (a[i] + h > a[i + 1]) {
lr[i] = lr[i + 1];
} else
lr[i] = i;
}
printf("%.9lf\n", dfs(1, n, 0, 0));
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
Alice wants to send an email to Miku on her mobile phone.
The only buttons that can be used for input on mobile phones are number buttons. Therefore, in order to input characters, the number buttons are pressed several times to input characters. The following characters are assigned to the number buttons of the mobile phone, and the confirmation button is assigned to button 0. With this mobile phone, you are supposed to press the confirm button after you finish entering one character.
* 1:.,!? (Space)
* 2: a b c
* 3: d e f
* 4: g h i
* 5: j k l
* 6: m n o
* 7: p q r s
* 8: t u v
* 9: w x y z
* 0: Confirm button
For example, if you press button 2, button 2, or button 0, the letter changes from'a'to'b', and the confirm button is pressed here, so the letter b is output. If you enter the same number in succession, the changing characters will loop. That is, if you press button 2 five times and then button 0, the letters change from'a'→' b'→'c' →'a' →'b', and the confirm button is pressed here. 'b' is output.
You can press the confirm button when no button is pressed, but in that case no characters are output.
Your job is to recreate the message Alice created from a row of buttons pressed by Alice.
Input
The first line gives the number of test cases. Each test case is then given a string of digits up to 1024 in length in one row.
Output
Print the string of Alice's message line by line for each test case. However, you can assume that the output is one or more and less than 76 characters.
Example
Input
5
20
220
222220
44033055505550666011011111090666077705550301110
000555555550000330000444000080000200004440000
Output
a
b
b
hello, world!
keitai
### Response
```cpp
#include <iostream>
#include <string>
#include <cstdlib>
#include <sstream>
using namespace std;
int main(){
int N;
cin >> N;
for(int i=0;i<N;i++){
string key[]={".,!? ","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"};
string input;
cin>>input;
stringstream b(input);
int num=0,count=0;
while(1){
char c;
if(!(b>>c))break;
int input=c-'0';
if(input!=0){
count++;
num=input;
}
else {
if(count!=0)
cout<<key[num-1][(count-1)%key[num-1].size()];
num=0;count=0;
}
}
cout<<endl;
}
return 0;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
Having stayed home alone, Petya decided to watch forbidden films on the Net in secret. "What ungentlemanly behavior!" — you can say that, of course, but don't be too harsh on the kid. In his country films about the Martians and other extraterrestrial civilizations are forbidden. It was very unfair to Petya as he adored adventure stories that featured lasers and robots.
Today Petya is watching a shocking blockbuster about the Martians called "R2:D2". What can "R2:D2" possibly mean? It might be the Martian time represented in the Martian numeral system. Petya knows that time on Mars is counted just like on the Earth (that is, there are 24 hours and each hour has 60 minutes). The time is written as "a:b", where the string a stands for the number of hours (from 0 to 23 inclusive), and string b stands for the number of minutes (from 0 to 59 inclusive). The only thing Petya doesn't know is in what numeral system the Martian time is written.
Your task is to print the radixes of all numeral system which can contain the time "a:b".
Input
The first line contains a single string as "a:b" (without the quotes). There a is a non-empty string, consisting of numbers and uppercase Latin letters. String a shows the number of hours. String b is a non-empty string that consists of numbers and uppercase Latin letters. String b shows the number of minutes. The lengths of strings a and b are from 1 to 5 characters, inclusive. Please note that strings a and b can have leading zeroes that do not influence the result in any way (for example, string "008:1" in decimal notation denotes correctly written time).
We consider characters 0, 1, ..., 9 as denoting the corresponding digits of the number's representation in some numeral system, and characters A, B, ..., Z correspond to numbers 10, 11, ..., 35.
Output
Print the radixes of the numeral systems that can represent the time "a:b" in the increasing order. Separate the numbers with spaces or line breaks. If there is no numeral system that can represent time "a:b", print the single integer 0. If there are infinitely many numeral systems that can represent the time "a:b", print the single integer -1.
Note that on Mars any positional numeral systems with positive radix strictly larger than one are possible.
Examples
Input
11:20
Output
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
Input
2A:13
Output
0
Input
000B:00001
Output
-1
Note
Let's consider the first sample. String "11:20" can be perceived, for example, as time 4:6, represented in the ternary numeral system or as time 17:32 in hexadecimal system.
Let's consider the second sample test. String "2A:13" can't be perceived as correct time in any notation. For example, let's take the base-11 numeral notation. There the given string represents time 32:14 that isn't a correct time.
Let's consider the third sample. String "000B:00001" can be perceived as a correct time in the infinite number of numeral systems. If you need an example, you can take any numeral system with radix no less than 12.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
bool isprime(int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
vector<long long int> prime;
void sieve(int n) {
bool bakh[n + 1];
memset(bakh, true, sizeof(bakh));
for (int p = 2; p * p <= n; p++) {
if (bakh[p] == true) {
for (int i = p * p; i <= n; i += p) bakh[i] = false;
}
}
for (int p = 2; p <= n; p++)
if (bakh[p]) prime.push_back(p);
}
long long int eulertotient(long long int z) {
long long int fac = z;
for (long long int i = 0; prime[i] * prime[i] <= z; i++) {
if (z % prime[i] == 0) {
fac -= (fac / prime[i]);
while (z % prime[i] == 0) z /= prime[i];
}
}
if (z > 1) fac -= (fac / z);
return fac;
}
long long int power(long long int x, long long int y, long long int p) {
long long int res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long int gcd(long long int a, long long int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long int lcm(long long int a, long long int b) {
long long int g = gcd(a, b);
long long int ans = (a * b) / g;
return ans;
}
long long int modInverse(long long int a, long long int m) {
long long int hvf = gcd(a, m);
if (hvf == 1) return power(a, m - 2, m);
return -1;
}
void multiply(long long int F[2][2], long long int M[2][2]) {
long long int x = F[0][0] * M[0][0] + F[0][1] * M[1][0];
long long int y = F[0][0] * M[0][1] + F[0][1] * M[1][1];
long long int z = F[1][0] * M[0][0] + F[1][1] * M[1][0];
long long int w = F[1][0] * M[0][1] + F[1][1] * M[1][1];
F[0][0] = x;
F[0][1] = y;
F[1][0] = z;
F[1][1] = w;
}
void powermat(long long int F[2][2], long long int n) {
if (n == 0 || n == 1) return;
long long int M[2][2] = {{1, 1}, {1, 0}};
powermat(F, n / 2);
multiply(F, F);
if (n % 2 != 0) multiply(F, M);
}
long long int fib(long long int n) {
long long int F[2][2] = {{1, 1}, {1, 0}};
if (n == 0) return 0;
powermat(F, n - 1);
return F[0][0];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
string st;
cin >> st;
long long int l = st.length();
long long int p = st.find(':');
long long int x, q = 0, Min = 0;
for (long long int i = 0; i < l; i++) {
if (st[i] == ':') continue;
x = st[i] - 48;
if (x > 9) x -= 7;
q = max(q, x);
}
q += 1;
long long int b[2];
long long int k = 0;
b[0] = 0;
b[1] = 0;
long long int c = 0;
for (long long int i = q; i <= 60; i++) {
k = 0;
b[0] = 0;
b[1] = 0;
for (long long int j = 0; j < l; j++) {
if (st[j] == ':') {
k += 1;
continue;
}
x = st[j] - 48;
if (x > 9) x -= 7;
q = max(q, x);
b[k] = b[k] * i + x;
}
if (b[0] <= 23 && b[1] < 60)
c++;
else
break;
}
if (c == 0) {
cout << 0 << endl;
return 0;
}
long long int s[2] = {0};
k = 0;
for (long long int i = 0; i < l; i++) {
if (st[i] == ':') {
k++;
continue;
}
x = st[i] - 48;
if (x > 9) x -= 7;
q = max(q, x);
s[k] = s[k] * 100 + x;
}
if (s[0] < 24 && s[1] < 60) {
cout << -1 << endl;
return 0;
}
for (long long int i = 0; i < c; i++) cout << q + i << " ";
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
Let's look at the following process: initially you have an empty stack and an array s of the length l. You are trying to push array elements to the stack in the order s_1, s_2, s_3, ... s_{l}. Moreover, if the stack is empty or the element at the top of this stack is not equal to the current element, then you just push the current element to the top of the stack. Otherwise, you don't push the current element to the stack and, moreover, pop the top element of the stack.
If after this process the stack remains empty, the array s is considered stack exterminable.
There are samples of stack exterminable arrays:
* [1, 1];
* [2, 1, 1, 2];
* [1, 1, 2, 2];
* [1, 3, 3, 1, 2, 2];
* [3, 1, 3, 3, 1, 3];
* [3, 3, 3, 3, 3, 3];
* [5, 1, 2, 2, 1, 4, 4, 5];
Let's consider the changing of stack more details if s = [5, 1, 2, 2, 1, 4, 4, 5] (the top of stack is highlighted).
1. after pushing s_1 = 5 the stack turn into [5];
2. after pushing s_2 = 1 the stack turn into [5, 1];
3. after pushing s_3 = 2 the stack turn into [5, 1, 2];
4. after pushing s_4 = 2 the stack turn into [5, 1];
5. after pushing s_5 = 1 the stack turn into [5];
6. after pushing s_6 = 4 the stack turn into [5, 4];
7. after pushing s_7 = 4 the stack turn into [5];
8. after pushing s_8 = 5 the stack is empty.
You are given an array a_1, a_2, …, a_n. You have to calculate the number of its subarrays which are stack exterminable.
Note, that you have to answer q independent queries.
Input
The first line contains one integer q (1 ≤ q ≤ 3 ⋅ 10^5) — the number of queries.
The first line of each query contains one integer n (1 ≤ n ≤ 3 ⋅ 10^5) — the length of array a.
The second line of each query contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ n) — the elements.
It is guaranteed that the sum of all n over all queries does not exceed 3 ⋅ 10^5.
Output
For each test case print one integer in single line — the number of stack exterminable subarrays of the array a.
Example
Input
3
5
2 1 1 2 2
6
1 2 1 1 3 2
9
3 1 2 2 1 6 6 3 3
Output
4
1
8
Note
In the first query there are four stack exterminable subarrays: a_{1 … 4} = [2, 1, 1, 2], a_{2 … 3} = [1, 1], a_{2 … 5} = [1, 1, 2, 2], a_{4 … 5} = [2, 2].
In the second query, only one subarray is exterminable subarray — a_{3 … 4}.
In the third query, there are eight stack exterminable subarrays: a_{1 … 8}, a_{2 … 5}, a_{2 … 7}, a_{2 … 9}, a_{3 … 4}, a_{6 … 7}, a_{6 … 9}, a_{8 … 9}.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1008691207;
const long long inf = mod * mod;
const long long d2 = (mod + 1) / 2;
const double EPS = 1e-10;
const double INF = 1e+10;
const double PI = acos(-1.0);
const int C_SIZE = 3121000;
namespace {
long long fact[C_SIZE];
long long finv[C_SIZE];
long long inv[C_SIZE];
long long Comb(int a, int b) {
if (a < b || b < 0) return 0;
return fact[a] * finv[b] % mod * finv[a - b] % mod;
}
void init_C(int n) {
fact[0] = finv[0] = inv[1] = 1;
for (int i = 2; i < n; i++) {
inv[i] = (mod - (mod / i) * inv[mod % i] % mod) % mod;
}
for (int i = 1; i < n; i++) {
fact[i] = fact[i - 1] * i % mod;
finv[i] = finv[i - 1] * inv[i] % mod;
}
}
long long pw(long long a, long long b) {
if (a < 0LL) return 0;
if (b < 0LL) return 0;
long long ret = 1;
while (b) {
if (b % 2) ret = ret * a % mod;
a = a * a % mod;
b /= 2;
}
return ret;
}
long long pw_mod(long long a, long long b, long long M) {
if (a < 0LL) return 0;
if (b < 0LL) return 0;
long long ret = 1;
while (b) {
if (b % 2) ret = ret * a % M;
a = a * a % M;
b /= 2;
}
return ret;
}
int ABS(int a) { return max(a, -a); }
long long ABS(long long a) { return max(a, -a); }
double ABS(double a) { return max(a, -a); }
int sig(double r) { return (r < -EPS) ? -1 : (r > +EPS) ? +1 : 0; }
} // namespace
int p[310000];
int par[310000];
int num[310000];
int cnt[310000];
map<pair<int, int>, int> M;
int main() {
int Q;
scanf("%d", &Q);
while (Q--) {
int a;
scanf("%d", &a);
for (int i = 0; i < a; i++) {
scanf("%d", p + i);
p[i]--;
}
for (int i = 0; i <= a + 10; i++) {
par[i] = num[i] = cnt[i] = 0;
}
M.clear();
long long ret = 0;
int at = 0;
int sz = 1;
num[at] = -1;
cnt[at] = 1;
for (int i = 0; i < a; i++) {
if (p[i] == num[at]) {
at = par[at];
} else {
if (M.count(make_pair(at, p[i]))) {
int id = M[make_pair(at, p[i])];
at = id;
} else {
M[make_pair(at, p[i])] = sz;
num[sz] = p[i];
par[sz] = at;
at = sz;
sz++;
}
}
ret += cnt[at];
cnt[at]++;
}
printf("%lld\n", ret);
}
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
Limak is a grizzly bear. He is big and dreadful. You were chilling in the forest when you suddenly met him. It's very unfortunate for you. He will eat all your cookies unless you can demonstrate your mathematical skills. To test you, Limak is going to give you a puzzle to solve.
It's a well-known fact that Limak, as every bear, owns a set of numbers. You know some information about the set:
* The elements of the set are distinct positive integers.
* The number of elements in the set is n. The number n is divisible by 5.
* All elements are between 1 and b, inclusive: bears don't know numbers greater than b.
* For each r in {0, 1, 2, 3, 4}, the set contains exactly <image> elements that give remainder r when divided by 5. (That is, there are <image> elements divisible by 5, <image> elements of the form 5k + 1, <image> elements of the form 5k + 2, and so on.)
Limak smiles mysteriously and gives you q hints about his set. The i-th hint is the following sentence: "If you only look at elements that are between 1 and upToi, inclusive, you will find exactly quantityi such elements in my set."
In a moment Limak will tell you the actual puzzle, but something doesn't seem right... That smile was very strange. You start to think about a possible reason. Maybe Limak cheated you? Or is he a fair grizzly bear?
Given n, b, q and hints, check whether Limak can be fair, i.e. there exists at least one set satisfying the given conditions. If it's possible then print ''fair". Otherwise, print ''unfair".
Input
The first line contains three integers n, b and q (5 ≤ n ≤ b ≤ 104, 1 ≤ q ≤ 104, n divisible by 5) — the size of the set, the upper limit for numbers in the set and the number of hints.
The next q lines describe the hints. The i-th of them contains two integers upToi and quantityi (1 ≤ upToi ≤ b, 0 ≤ quantityi ≤ n).
Output
Print ''fair" if there exists at least one set that has all the required properties and matches all the given hints. Otherwise, print ''unfair".
Examples
Input
10 20 1
10 10
Output
fair
Input
10 20 3
15 10
5 0
10 5
Output
fair
Input
10 20 2
15 3
20 10
Output
unfair
Note
In the first example there is only one set satisfying all conditions: {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}.
In the second example also there is only one set satisfying all conditions: {6, 7, 8, 9, 10, 11, 12, 13, 14, 15}.
Easy to see that there is no set satisfying all conditions from the third example. So Limak lied to you :-(
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 10105;
int n, b, q, st, ed;
int First[maxn], cnt, dis[maxn];
struct edge {
int to, Next, flow, c;
} Tree[maxn * 100];
void init() {
cnt = 0;
memset(First, -1, sizeof(First));
}
void addedge(int from, int to, int flow) {
Tree[cnt].to = to;
Tree[cnt].Next = First[from];
Tree[cnt].flow = flow;
First[from] = cnt++;
Tree[cnt].to = from;
Tree[cnt].Next = First[to];
Tree[cnt].flow = 0;
First[to] = cnt++;
}
bool bfs(int st, int ed) {
memset(dis, 0, sizeof(dis));
queue<int> Q;
dis[st] = 1;
Q.push(st);
while (!Q.empty()) {
int u = Q.front();
Q.pop();
for (int i = First[u]; i != -1; i = Tree[i].Next) {
int v = Tree[i].to;
int flow = Tree[i].flow;
if (flow && !dis[v]) {
dis[v] = dis[u] + 1;
if (v == ed) return true;
Q.push(v);
}
}
}
return false;
}
int dfs(int u, int minf) {
if (u == ed) {
return minf;
}
if (minf == 0) return minf;
int f = 0;
for (int i = First[u]; i != -1; i = Tree[i].Next) {
int v = Tree[i].to;
if (Tree[i].flow && dis[v] == dis[u] + 1) {
int tmp = dfs(v, min(Tree[i].flow, minf));
Tree[i].flow -= tmp;
Tree[i ^ 1].flow += tmp;
f += tmp;
minf -= tmp;
if (minf == 0) return f;
}
}
return f;
}
int dinic(int st, int ed) {
int res = 0;
while (bfs(st, ed)) res += dfs(st, INF);
return res;
}
struct node {
int up, num;
bool operator<(const node& A) const {
if (A.up != up) return A.up > up;
return A.num > num;
}
} ax[10005];
int sum[10];
int main() {
init();
scanf("%d%d%d", &n, &b, &q);
st = 0, ed = q + 5 + 10;
for (int i = 1; i <= q; i++) scanf("%d%d", &ax[i].up, &ax[i].num);
sort(ax + 1, ax + 1 + q);
ax[q + 1].up = b, ax[q + 1].num = n;
for (int i = 1; i <= q + 1; i++) {
int nowv = ax[i].up - ax[i - 1].up;
int nowb = ax[i].num - ax[i - 1].num;
if (ax[i].num > n || nowb > nowv || nowb < 0) {
puts("unfair");
return 0;
}
for (int j = ax[i - 1].up + 1; j <= ax[i].up; j++) {
sum[j % 5]++;
}
for (int j = 0; j < 5; j++) addedge(i, q + j + 2, sum[j]);
addedge(st, i, nowb);
memset(sum, 0, sizeof(sum));
}
for (int i = 1; i <= 5; i++) addedge(q + i + 1, ed, n / 5);
int max1 = dinic(st, ed);
if (max1 == n)
puts("fair");
else
puts("unfair");
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
VK news recommendation system daily selects interesting publications of one of n disjoint categories for each user. Each publication belongs to exactly one category. For each category i batch algorithm selects a_i publications.
The latest A/B test suggests that users are reading recommended publications more actively if each category has a different number of publications within daily recommendations. The targeted algorithm can find a single interesting publication of i-th category within t_i seconds.
What is the minimum total time necessary to add publications to the result of batch algorithm execution, so all categories have a different number of publications? You can't remove publications recommended by the batch algorithm.
Input
The first line of input consists of single integer n — the number of news categories (1 ≤ n ≤ 200 000).
The second line of input consists of n integers a_i — the number of publications of i-th category selected by the batch algorithm (1 ≤ a_i ≤ 10^9).
The third line of input consists of n integers t_i — time it takes for targeted algorithm to find one new publication of category i (1 ≤ t_i ≤ 10^5).
Output
Print one integer — the minimal required time for the targeted algorithm to get rid of categories with the same size.
Examples
Input
5
3 7 9 7 8
5 2 5 7 5
Output
6
Input
5
1 2 3 4 5
1 1 1 1 1
Output
0
Note
In the first example, it is possible to find three publications of the second type, which will take 6 seconds.
In the second example, all news categories contain a different number of publications.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long p = 1e9 + 7;
long long power(long long a, long long b) {
long long res = 1;
while (b) {
if (b % 2) {
res = (res * a) % p;
}
a = (a * a) % p;
b /= 2;
}
return res;
}
long long inv(long long a) { return power(a, p - 2); }
void dijks(vector<vector<pair<int, int> > > &adj, int s, vector<int> &d) {
d[s] = 0;
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
pq;
pq.push(make_pair(d[s], 0));
while (!pq.empty()) {
pair<int, int> temp = pq.top();
pq.pop();
int u = temp.second;
if (d[u] < temp.first) continue;
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i].first;
int wt = adj[u][i].second;
if (d[v] <= d[u] + wt)
continue;
else {
d[v] = d[u] + wt;
pq.push(make_pair(d[v], v));
}
}
}
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
a %= b;
return gcd(b, a);
}
int main() {
int t = 1;
while (t--) {
int n;
cin >> n;
vector<pair<long long, long long> > a(n);
for (int i = 0; i < n; i++) cin >> a[i].first;
for (int i = 0; i < n; i++) cin >> a[i].second;
long long ans = 0;
sort(a.begin(), a.end());
priority_queue<long long> pq;
long long sum = 0;
for (int i = 0; i < n;) {
long long ind = i;
long long num = a[i].first;
while (num == a[i].first) i++;
if (!pq.empty() || i - ind > 1) {
for (int x = ind; x < i; x++) {
sum += a[x].second;
pq.push(a[x].second);
}
while (i == n || num < a[i].first) {
if (!pq.empty())
sum -= pq.top();
else
break;
pq.pop();
ans += sum;
num++;
}
}
}
cout << ans << endl;
}
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
Karen has just arrived at school, and she has a math test today!
<image>
The test is about basic addition and subtraction. Unfortunately, the teachers were too busy writing tasks for Codeforces rounds, and had no time to make an actual test. So, they just put one question in the test that is worth all the points.
There are n integers written on a row. Karen must alternately add and subtract each pair of adjacent integers, and write down the sums or differences on the next row. She must repeat this process on the values on the next row, and so on, until only one integer remains. The first operation should be addition.
Note that, if she ended the previous row by adding the integers, she should start the next row by subtracting, and vice versa.
The teachers will simply look at the last integer, and then if it is correct, Karen gets a perfect score, otherwise, she gets a zero for the test.
Karen has studied well for this test, but she is scared that she might make a mistake somewhere and it will cause her final answer to be wrong. If the process is followed, what number can she expect to be written on the last row?
Since this number can be quite large, output only the non-negative remainder after dividing it by 109 + 7.
Input
The first line of input contains a single integer n (1 ≤ n ≤ 200000), the number of numbers written on the first row.
The next line contains n integers. Specifically, the i-th one among these is ai (1 ≤ ai ≤ 109), the i-th number on the first row.
Output
Output a single integer on a line by itself, the number on the final row after performing the process above.
Since this number can be quite large, print only the non-negative remainder after dividing it by 109 + 7.
Examples
Input
5
3 6 9 12 15
Output
36
Input
4
3 7 5 2
Output
1000000006
Note
In the first test case, the numbers written on the first row are 3, 6, 9, 12 and 15.
Karen performs the operations as follows:
<image>
The non-negative remainder after dividing the final number by 109 + 7 is still 36, so this is the correct output.
In the second test case, the numbers written on the first row are 3, 7, 5 and 2.
Karen performs the operations as follows:
<image>
The non-negative remainder after dividing the final number by 109 + 7 is 109 + 6, so this is the correct output.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5, MOD = 1000000007;
template <typename T>
void read(T &x) {
bool neg = false;
unsigned char c = getchar();
for (; (c ^ 48) > 9; c = getchar())
if (c == '-') neg = true;
for (x = 0; (c ^ 48) < 10; c = getchar()) x = (x << 3) + (x << 1) + (c ^ 48);
if (neg) x = -x;
}
int n, a[N], f[N] = {1}, m, ans;
inline int pow(int a1, int b) {
long long a = a1, c = 1;
while (b) {
if (b & 1) c *= a, c %= MOD;
a *= a, a %= MOD;
b >>= 1;
}
return (int)c;
}
inline int inv(int a) { return pow(a, MOD - 2); }
int main() {
read(n);
for (int i = 0, i_end = n; i < i_end; ++i) read(a[i]);
if (n == 1) return printf("%d\n", a[0]), 0;
m = (n >> 1) - 1;
for (int i = 1, i_end = m + 1; i < i_end; ++i)
f[i] = (long long)f[i - 1] * i % MOD;
if (((long long)n * (n - 1)) & 2) {
if (n & 1)
for (int i = 0, i_end = --n; i < i_end; ++i)
if (i & 1)
a[i] -= a[i + 1];
else
a[i] += a[i + 1];
for (int i = 0, i_end = n; i < i_end; ++i) a[i] %= MOD;
for (int i = 0, i_end = n >> 1; i < i_end; ++i) {
long long b = a[i << 1] + a[(i << 1) + 1];
ans += b * f[m] % MOD * inv((long long)f[i] * f[m - i] % MOD) % MOD;
ans %= MOD;
}
} else {
if (n & 1)
for (int i = 0, i_end = --n; i < i_end; ++i)
if (i & 1)
a[i] -= a[i + 1];
else
a[i] += a[i + 1];
for (int i = 0, i_end = n; i < i_end; ++i) a[i] %= MOD;
for (int i = 0, i_end = n >> 1; i < i_end; ++i) {
long long b = a[i << 1] - a[(i << 1) + 1];
ans += b * f[m] % MOD * inv((long long)f[i] * f[m - i] % MOD) % MOD;
ans %= MOD;
}
}
ans += MOD;
ans %= MOD;
printf("%d\n", ans);
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
Little Artyom decided to study probability theory. He found a book with a lot of nice exercises and now wants you to help him with one of them.
Consider two dices. When thrown each dice shows some integer from 1 to n inclusive. For each dice the probability of each outcome is given (of course, their sum is 1), and different dices may have different probability distributions.
We throw both dices simultaneously and then calculate values max(a, b) and min(a, b), where a is equal to the outcome of the first dice, while b is equal to the outcome of the second dice. You don't know the probability distributions for particular values on each dice, but you know the probability distributions for max(a, b) and min(a, b). That is, for each x from 1 to n you know the probability that max(a, b) would be equal to x and the probability that min(a, b) would be equal to x. Find any valid probability distribution for values on the dices. It's guaranteed that the input data is consistent, that is, at least one solution exists.
Input
First line contains the integer n (1 ≤ n ≤ 100 000) — the number of different values for both dices.
Second line contains an array consisting of n real values with up to 8 digits after the decimal point — probability distribution for max(a, b), the i-th of these values equals to the probability that max(a, b) = i. It's guaranteed that the sum of these values for one dice is 1. The third line contains the description of the distribution min(a, b) in the same format.
Output
Output two descriptions of the probability distribution for a on the first line and for b on the second line.
The answer will be considered correct if each value of max(a, b) and min(a, b) probability distribution values does not differ by more than 10 - 6 from ones given in input. Also, probabilities should be non-negative and their sums should differ from 1 by no more than 10 - 6.
Examples
Input
2
0.25 0.75
0.75 0.25
Output
0.5 0.5
0.5 0.5
Input
3
0.125 0.25 0.625
0.625 0.25 0.125
Output
0.25 0.25 0.5
0.5 0.25 0.25
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
int n;
double prea[maxn], sufb[maxn];
double sum1[maxn], sum2[maxn];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
double x;
scanf("%lf", &x);
prea[i] = prea[i - 1] + x;
}
for (int i = 1; i <= n; i++) scanf("%lf", &sufb[i]);
for (int i = n; i >= 1; i--) sufb[i] += sufb[i + 1];
for (int i = 1; i <= n; i++) {
double aa = 1;
double bb = -(1 + prea[i] - sufb[i + 1]);
double cc = prea[i];
double delta = max(0.0, bb * bb - 4 * aa * cc);
sum1[i] = (-bb - sqrt(delta)) / (2 * aa);
sum2[i] = (-bb + sqrt(delta)) / (2 * aa);
}
for (int i = 1; i <= n; i++)
printf("%.12f%c", sum2[i] - sum2[i - 1], i == n ? '\n' : ' ');
for (int i = 1; i <= n; i++)
printf("%.12f%c", sum1[i] - sum1[i - 1], i == n ? '\n' : ' ');
return 0;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
The Smart Beaver from ABBYY has a long history of cooperating with the "Institute of Cytology and Genetics". Recently, the Institute staff challenged the Beaver with a new problem. The problem is as follows.
There is a collection of n proteins (not necessarily distinct). Each protein is a string consisting of lowercase Latin letters. The problem that the scientists offered to the Beaver is to select a subcollection of size k from the initial collection of proteins so that the representativity of the selected subset of proteins is maximum possible.
The Smart Beaver from ABBYY did some research and came to the conclusion that the representativity of a collection of proteins can be evaluated by a single number, which is simply calculated. Let's suppose we have a collection {a1, ..., ak} consisting of k strings describing proteins. The representativity of this collection is the following value:
<image>
where f(x, y) is the length of the longest common prefix of strings x and y; for example, f("abc", "abd") = 2, and f("ab", "bcd") = 0.
Thus, the representativity of collection of proteins {"abc", "abd", "abe"} equals 6, and the representativity of collection {"aaa", "ba", "ba"} equals 2.
Having discovered that, the Smart Beaver from ABBYY asked the Cup contestants to write a program that selects, from the given collection of proteins, a subcollection of size k which has the largest possible value of representativity. Help him to solve this problem!
Input
The first input line contains two integers n and k (1 ≤ k ≤ n), separated by a single space. The following n lines contain the descriptions of proteins, one per line. Each protein is a non-empty string of no more than 500 characters consisting of only lowercase Latin letters (a...z). Some of the strings may be equal.
The input limitations for getting 20 points are:
* 1 ≤ n ≤ 20
The input limitations for getting 50 points are:
* 1 ≤ n ≤ 100
The input limitations for getting 100 points are:
* 1 ≤ n ≤ 2000
Output
Print a single number denoting the largest possible value of representativity that a subcollection of size k of the given collection of proteins can have.
Examples
Input
3 2
aba
bzd
abq
Output
2
Input
4 3
eee
rrr
ttt
qqq
Output
0
Input
4 3
aaa
abba
abbc
abbd
Output
9
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2005;
int n, k;
string a[MAXN];
int lcp[MAXN];
int dp[MAXN * 2][MAXN], cn = 0;
int work(int l, int r) {
cn++;
if (l == r) return cn;
int d = cn;
int p = l;
for (int i = l; i < r; i++)
if (lcp[i] < lcp[p]) p = i;
int lch = work(l, p);
int rch = work(p + 1, r);
for (int i = 0; i <= p - l + 1; i++)
for (int j = 0; j <= r - p; j++) {
int tmp = dp[lch][i] + dp[rch][j] + lcp[p] * i * j;
if (tmp > dp[d][i + j]) dp[d][i + j] = tmp;
}
return d;
}
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
for (int i = 1; i < n; i++) {
lcp[i] = -1;
for (int j = 0; j < a[i].length() && j < a[i + 1].length(); j++)
if (a[i][j] != a[i + 1][j]) {
lcp[i] = j;
break;
}
if (lcp[i] == -1) lcp[i] = min(a[i].length(), a[i + 1].length());
}
work(1, n);
cout << dp[1][k] << endl;
return 0;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
Vasilisa the Wise from the Kingdom of Far Far Away got a magic box with a secret as a present from her friend Hellawisa the Wise from the Kingdom of A Little Closer. However, Vasilisa the Wise does not know what the box's secret is, since she cannot open it again. She hopes that you will help her one more time with that.
The box's lock looks as follows: it contains 4 identical deepenings for gems as a 2 × 2 square, and some integer numbers are written at the lock's edge near the deepenings. The example of a lock is given on the picture below.
<image>
The box is accompanied with 9 gems. Their shapes match the deepenings' shapes and each gem contains one number from 1 to 9 (each number is written on exactly one gem). The box will only open after it is decorated with gems correctly: that is, each deepening in the lock should be filled with exactly one gem. Also, the sums of numbers in the square's rows, columns and two diagonals of the square should match the numbers written at the lock's edge. For example, the above lock will open if we fill the deepenings with gems with numbers as is shown on the picture below.
<image>
Now Vasilisa the Wise wants to define, given the numbers on the box's lock, which gems she should put in the deepenings to open the box. Help Vasilisa to solve this challenging task.
Input
The input contains numbers written on the edges of the lock of the box. The first line contains space-separated integers r1 and r2 that define the required sums of numbers in the rows of the square. The second line contains space-separated integers c1 and c2 that define the required sums of numbers in the columns of the square. The third line contains space-separated integers d1 and d2 that define the required sums of numbers on the main and on the side diagonals of the square (1 ≤ r1, r2, c1, c2, d1, d2 ≤ 20). Correspondence between the above 6 variables and places where they are written is shown on the picture below. For more clarifications please look at the second sample test that demonstrates the example given in the problem statement.
<image>
Output
Print the scheme of decorating the box with stones: two lines containing two space-separated integers from 1 to 9. The numbers should be pairwise different. If there is no solution for the given lock, then print the single number "-1" (without the quotes).
If there are several solutions, output any.
Examples
Input
3 7
4 6
5 5
Output
1 2
3 4
Input
11 10
13 8
5 16
Output
4 7
9 1
Input
1 2
3 4
5 6
Output
-1
Input
10 10
10 10
10 10
Output
-1
Note
Pay attention to the last test from the statement: it is impossible to open the box because for that Vasilisa the Wise would need 4 identical gems containing number "5". However, Vasilisa only has one gem with each number from 1 to 9.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int c1, c2, d1, d2, r1, r2, i, j, k, l;
cin >> r1 >> r2 >> c1 >> c2 >> d1 >> d2;
for (i = 1; i < 10; i++) {
j = r1 - i;
k = c1 - i;
l = d1 - i;
if (i != j && i != k && i != l && j != k && j != l && k != l && j < 10 &&
k < 10 && l < 10 && j > 0 && k > 0 && l > 0) {
if (c2 == j + l && r2 == k + l && d2 == k + j) {
cout << i << " " << j << "\n" << k << " " << l;
return 0;
}
}
}
cout << "-1";
return 0;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
Luba is surfing the Internet. She currently has n opened tabs in her browser, indexed from 1 to n from left to right. The mouse cursor is currently located at the pos-th tab. Luba needs to use the tabs with indices from l to r (inclusive) for her studies, and she wants to close all the tabs that don't belong to this segment as fast as possible.
Each second Luba can either try moving the cursor to the left or to the right (if the cursor is currently at the tab i, then she can move it to the tab max(i - 1, a) or to the tab min(i + 1, b)) or try closing all the tabs to the left or to the right of the cursor (if the cursor is currently at the tab i, she can close all the tabs with indices from segment [a, i - 1] or from segment [i + 1, b]). In the aforementioned expressions a and b denote the minimum and maximum index of an unclosed tab, respectively. For example, if there were 7 tabs initially and tabs 1, 2 and 7 are closed, then a = 3, b = 6.
What is the minimum number of seconds Luba has to spend in order to leave only the tabs with initial indices from l to r inclusive opened?
Input
The only line of input contains four integer numbers n, pos, l, r (1 ≤ n ≤ 100, 1 ≤ pos ≤ n, 1 ≤ l ≤ r ≤ n) — the number of the tabs, the cursor position and the segment which Luba needs to leave opened.
Output
Print one integer equal to the minimum number of seconds required to close all the tabs outside the segment [l, r].
Examples
Input
6 3 2 4
Output
5
Input
6 3 1 3
Output
1
Input
5 2 1 5
Output
0
Note
In the first test Luba can do the following operations: shift the mouse cursor to the tab 2, close all the tabs to the left of it, shift the mouse cursor to the tab 3, then to the tab 4, and then close all the tabs to the right of it.
In the second test she only needs to close all the tabs to the right of the current position of the cursor.
In the third test Luba doesn't need to do anything.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, pos, l, r;
cin >> n >> pos >> l >> r;
int res = 0;
if (l == 1 and r == n) {
return cout << res, 0;
}
if (l == 1) {
if (pos <= r) {
res += (r - pos + 1);
} else {
res += (pos - r + 1);
}
return cout << res, 0;
}
if (r == n) {
if (pos >= l) {
res += (pos - l + 1);
} else {
res += (l - pos + 1);
}
return cout << res, 0;
}
if (pos >= l and pos <= r) {
int d = (l + r) / 2;
if (pos > d) {
res += (r - pos) + 1;
res += (r - l) + 1;
} else {
res += (pos - l) + 1;
res += (r - l) + 1;
}
} else if (pos < l) {
res += (l - pos) + 1;
res += (r - l) + 1;
} else if (pos > r) {
res += (pos - r + 1);
res += (r - l) + 1;
}
cout << res;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
Vasya learns to type. He has an unusual keyboard at his disposal: it is rectangular and it has n rows of keys containing m keys in each row. Besides, the keys are of two types. Some of the keys have lowercase Latin letters on them and some of the keys work like the "Shift" key on standard keyboards, that is, they make lowercase letters uppercase.
Vasya can press one or two keys with one hand. However, he can only press two keys if the Euclidean distance between the centers of the keys does not exceed x. The keys are considered as squares with a side equal to 1. There are no empty spaces between neighbouring keys.
Vasya is a very lazy boy, that's why he tries to type with one hand as he eats chips with his other one. However, it is possible that some symbol can't be typed with one hand only, because the distance between it and the closest "Shift" key is strictly larger than x. In this case he will have to use his other hand. Having typed the symbol, Vasya returns other hand back to the chips.
You are given Vasya's keyboard and the text. Count the minimum number of times Vasya will have to use the other hand.
Input
The first line contains three integers n, m, x (1 ≤ n, m ≤ 30, 1 ≤ x ≤ 50).
Next n lines contain descriptions of all the keyboard keys. Each line contains the descriptions of exactly m keys, without spaces. The letter keys are marked with the corresponding lowercase letters. The "Shift" keys are marked with the "S" symbol.
Then follow the length of the text q (1 ≤ q ≤ 5·105). The last line contains the text T, which consists of q symbols, which are uppercase and lowercase Latin letters.
Output
If Vasya can type the text, then print the minimum number of times he will have to use his other hand. Otherwise, print "-1" (without the quotes).
Examples
Input
2 2 1
ab
cd
1
A
Output
-1
Input
2 2 1
ab
cd
1
e
Output
-1
Input
2 2 1
ab
cS
5
abcBA
Output
1
Input
3 9 4
qwertyuio
asdfghjkl
SzxcvbnmS
35
TheQuIcKbRoWnFOXjummsovertHeLazYDOG
Output
2
Note
In the first sample the symbol "A" is impossible to print as there's no "Shift" key on the keyboard.
In the second sample the symbol "e" is impossible to print as there's no such key on the keyboard.
In the fourth sample the symbols "T", "G" are impossible to print with one hand. The other letters that are on the keyboard can be printed. Those symbols come up in the text twice, thus, the answer is 2.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, x;
cin >> n >> m >> x;
char a[34][34];
vector<pair<int, int> > v;
map<int, bool> p;
map<int, bool> r;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
cin >> a[i][j];
r[a[i][j]] = true;
if (a[i][j] == 'S') v.push_back(make_pair(i, j));
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (a[i][j] != 'S') {
for (int q = 0; q < v.size(); q++) {
int u = (abs(v[q].first - i)), hz = abs(v[q].second - j);
u *= u;
hz *= hz;
if (u + hz <= x * x) {
p[a[i][j]] = true;
break;
}
}
}
}
}
int z;
cin >> z;
string s;
cin >> s;
int ans = 0;
int w = 'a' - 'A';
for (int i = 0; i < z; i++) {
if (s[i] >= 'A' && s[i] <= 'Z') {
if (v.size() == 0) {
cout << -1;
return 0;
}
char c = tolower(s[i]);
if (!r[c]) {
cout << -1;
return 0;
} else if (!p[c])
ans++;
} else {
if (!r[s[i]]) {
cout << -1;
return 0;
}
}
}
cout << ans;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
Let's define an unambiguous arithmetic expression (UAE) as follows.
* All non-negative integers are UAE's. Integers may have leading zeroes (for example, 0000 and 0010 are considered valid integers).
* If X and Y are two UAE's, then "(X) + (Y)", "(X) - (Y)", "(X) * (Y)", and "(X) / (Y)" (all without the double quotes) are UAE's.
* If X is an UAE, then " - (X)" and " + (X)" (both without the double quotes) are UAE's.
You are given a string consisting only of digits ("0" - "9") and characters "-", "+", "*", and "/". Your task is to compute the number of different possible unambiguous arithmetic expressions such that if all brackets (characters "(" and ")") of that unambiguous arithmetic expression are removed, it becomes the input string. Since the answer may be very large, print it modulo 1000003 (106 + 3).
Input
The first line is a non-empty string consisting of digits ('0'-'9') and characters '-', '+', '*', and/or '/'. Its length will not exceed 2000. The line doesn't contain any spaces.
Output
Print a single integer representing the number of different unambiguous arithmetic expressions modulo 1000003 (106 + 3) such that if all its brackets are removed, it becomes equal to the input string (character-by-character).
Examples
Input
1+2*3
Output
2
Input
03+-30+40
Output
3
Input
5//4
Output
0
Input
5/0
Output
1
Input
1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1
Output
100728
Note
For the first example, the two possible unambiguous arithmetic expressions are:
((1) + (2)) * (3)
(1) + ((2) * (3))
For the second example, the three possible unambiguous arithmetic expressions are:
(03) + (( - (30)) + (40))
(03) + ( - ((30) + (40)))
((03) + ( - (30))) + (40)
### Response
```cpp
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
const int MAXN = 2000 + 5;
const int ha = 1e6 + 3;
char str[MAXN];
int a[MAXN];
int n;
int f[MAXN][MAXN], g[MAXN][MAXN];
int main() {
scanf("%s", str + 1);
int len = strlen(str + 1);
for (register int i = 1; i <= len; ++i) {
if (isdigit(str[i])) {
a[++n] = 0;
while (isdigit(str[i])) ++i;
--i;
} else {
if (str[i] == '+' || str[i] == '-')
a[++n] = 1;
else
a[++n] = 2;
}
}
for (register int i = 1; i <= n; ++i) f[i][i] = g[i][i] = !a[i];
for (register int l = n - 1; l >= 1; --l)
if (a[l] != 2) {
int *p1 = f[l] - 1;
for (register int r = l + 1; r <= n; ++r)
if (!a[r]) {
long long t = 0;
if (a[l] == 1) t = f[l + 1][r];
int *p2 = g[r] + 1;
for (register int k = l + 1; k <= r - 1; ++k)
if (a[k]) t += 1ll * p1[k] * p2[k];
f[l][r] = g[r][l] = t % ha;
}
}
printf("%d\n", f[1][n]);
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
You are given strings S and T consisting of lowercase English letters.
You can perform the following operation on S any number of times:
Operation: Choose two distinct lowercase English letters c_1 and c_2, then replace every occurrence of c_1 with c_2, and every occurrence of c_2 with c_1.
Determine if S and T can be made equal by performing the operation zero or more times.
Constraints
* 1 \leq |S| \leq 2 \times 10^5
* |S| = |T|
* S and T consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
T
Output
If S and T can be made equal, print `Yes`; otherwise, print `No`.
Examples
Input
azzel
apple
Output
Yes
Input
chokudai
redcoder
Output
No
Input
abcdefghijklmnopqrstuvwxyz
ibyhqfrekavclxjstdwgpzmonu
Output
Yes
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
string s,t;
int main(void)
{
int i;
int cnta[26]={0};
int cntb[26]={0};
cin>>s>>t;
for(i=0;i<s.size();i++)
{
cnta[s[i]-'a']++;
}
for(i=0;i<t.size();i++)
{
cntb[t[i]-'a']++;
}
sort(cnta,cnta+26);
sort(cntb,cntb+26);
for(i=0;i<26;i++)
{
if(cnta[i]!=cntb[i])
{
cout<<"No";
return 0;
}
}
cout<<"Yes";
return 0;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
You are given nonnegative integers a and b (a ≤ b), and a positive integer x. Among the integers between a and b, inclusive, how many are divisible by x?
Constraints
* 0 ≤ a ≤ b ≤ 10^{18}
* 1 ≤ x ≤ 10^{18}
Input
The input is given from Standard Input in the following format:
a b x
Output
Print the number of the integers between a and b, inclusive, that are divisible by x.
Examples
Input
4 8 2
Output
3
Input
0 5 1
Output
6
Input
9 9 2
Output
0
Input
1 1000000000000000000 3
Output
333333333333333333
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
int64_t a,b,x;
cin >>a>>b>>x;
int64_t ans;
ans=b/x-a/x;
if(a%x==0)
ans++;
cout <<ans<<endl;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Find the number of ways to choose a pair of an even number and an odd number from the positive integers between 1 and K (inclusive). The order does not matter.
Constraints
* 2\leq K\leq 100
* K is an integer.
Input
Input is given from Standard Input in the following format:
K
Output
Print the number of ways to choose a pair of an even number and an odd number from the positive integers between 1 and K (inclusive).
Examples
Input
3
Output
2
Input
6
Output
9
Input
11
Output
30
Input
50
Output
625
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(void){
int n;
cin >> n;
cout << n/2*(n-n/2) << endl;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
problem
There are the following games.
N characters are lined up in a vertical row. The color of these characters is red, blue, or yellow, and in the initial state, four or more characters of the same color are not lined up in a row. The player can select a character at a certain position and change it to another color. By this operation, if four or more characters of the same color are lined up in a row, those characters will disappear. When four or more characters of the same color are lined up in a row due to the disappearance of the characters, those characters also disappear, and this chain continues until there are no more places where four or more characters of the same color are lined up in a row. .. The purpose of this game is to reduce the number of characters remaining without disappearing.
For example, if the color of the sixth character from the top is changed from yellow to blue in the state at the left end of the figure below, five blue characters will disappear in a row, and finally three characters will remain without disappearing.
<image>
Given the color sequence of N characters in the initial state, create a program that finds the minimum value M of the number of characters that remain without disappearing when the color of the character is changed in only one place.
input
The input consists of multiple datasets. Each dataset is given in the following format.
The first line consists of only the number of characters N (1 ≤ N ≤ 10000). The following N lines contain one of 1, 2, and 3 integers, and the i + 1st line (1 ≤ i ≤ N) represents the color of the i-th character from the top in the initial state (1). Is red, 2 is blue, and 3 is yellow).
When N is 0, it indicates the end of input. The number of datasets does not exceed 5.
output
For each dataset, output the minimum value M of the number of characters remaining without disappearing on one line.
Examples
Input
12
3
2
1
1
2
3
2
2
2
1
1
3
12
3
2
1
1
2
3
2
1
3
2
1
3
0
Output
3
12
Input
None
Output
None
### Response
```cpp
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int n,chr[10000];
int go(int p,int dir){
int cr=chr[p];
while(chr[p]==cr){
if(dir==-1&&p<0)break;
if(dir==1&&p>=n)break;
p+=dir;
}
return p;
}
int del(int sp){
int u=sp,d=sp;
while(chr[u]==chr[d]){
int _u=go(u,-1),_d=go(d,1);
int dif=u-_u+(_d-d);
if(u==d)dif--;
if(dif<4)break;
u=_u;d=_d;
if(u<0||d>=n)break;
}
int ans=u+1+(n-d);
if(d==u)ans--;
return ans;
}
int main(){
while(cin>>n,n){
for(int i=0;i<n;i++)cin>>chr[i];
int Min=10000;
for(int i=0;i<n;i++){
for(int j=1;j<=3;j++){
if(chr[i]==j)continue;
int k=chr[i];
chr[i]=j;
Min=min(Min,del(i));
chr[i]=k;
}
}
cout<<Min<<endl;
}
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
Three people, A, B and C, are trying to communicate using transceivers. They are standing along a number line, and the coordinates of A, B and C are a, b and c (in meters), respectively. Two people can directly communicate when the distance between them is at most d meters. Determine if A and C can communicate, either directly or indirectly. Here, A and C can indirectly communicate when A and B can directly communicate and also B and C can directly communicate.
Constraints
* 1 ≤ a,b,c ≤ 100
* 1 ≤ d ≤ 100
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
a b c d
Output
If A and C can communicate, print `Yes`; if they cannot, print `No`.
Examples
Input
4 7 9 3
Output
Yes
Input
100 10 1 2
Output
No
Input
10 10 10 1
Output
Yes
Input
1 100 2 10
Output
Yes
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(){
int a,b,c,d;
cin>>a>>b>>c>>d;
if((fabs(a-b)<=d && fabs(b-c)<=d)||fabs(a-c)<=d)
cout<<"Yes";
else
cout<<"No";
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
Takahashi has decided to hold fastest-finger-fast quiz games. Kizahashi, who is in charge of making the scoreboard, is struggling to write the program that manages the players' scores in a game, which proceeds as follows.
A game is played by N players, numbered 1 to N. At the beginning of a game, each player has K points.
When a player correctly answers a question, each of the other N-1 players receives minus one (-1) point. There is no other factor that affects the players' scores.
At the end of a game, the players with 0 points or lower are eliminated, and the remaining players survive.
In the last game, the players gave a total of Q correct answers, the i-th of which was given by Player A_i. For Kizahashi, write a program that determines whether each of the N players survived this game.
Constraints
* All values in input are integers.
* 2 \leq N \leq 10^5
* 1 \leq K \leq 10^9
* 1 \leq Q \leq 10^5
* 1 \leq A_i \leq N\ (1 \leq i \leq Q)
Input
Input is given from Standard Input in the following format:
N K Q
A_1
A_2
.
.
.
A_Q
Output
Print N lines. The i-th line should contain `Yes` if Player i survived the game, and `No` otherwise.
Examples
Input
6 3 4
3
1
3
2
Output
No
No
Yes
No
No
No
Input
6 5 4
3
1
3
2
Output
Yes
Yes
Yes
Yes
Yes
Yes
Input
10 13 15
3
1
4
1
5
9
2
6
5
3
5
8
9
7
9
Output
No
No
No
No
Yes
No
No
No
Yes
No
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for(int i = 0; i < n; i++)
int main()
{
int N,K,Q;
cin >> N >> K >> Q;
vector<int> v(N);
rep(i,Q){
int n;
cin >> n;
v[n-1]++;
}
rep(i,N){
if(Q-v[i]>=K)cout <<"No"<<endl;
else cout << "Yes" <<endl;
}
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
The Berland road network consists of n cities and of m bidirectional roads. The cities are numbered from 1 to n, where the main capital city has number n, and the culture capital — number 1. The road network is set up so that it is possible to reach any city from any other one by the roads. Moving on each road in any direction takes the same time.
All residents of Berland are very lazy people, and so when they want to get from city v to city u, they always choose one of the shortest paths (no matter which one).
The Berland government wants to make this country's road network safer. For that, it is going to put a police station in one city. The police station has a rather strange property: when a citizen of Berland is driving along the road with a police station at one end of it, the citizen drives more carefully, so all such roads are considered safe. The roads, both ends of which differ from the city with the police station, are dangerous.
Now the government wonders where to put the police station so that the average number of safe roads for all the shortest paths from the cultural capital to the main capital would take the maximum value.
Input
The first input line contains two integers n and m (2 ≤ n ≤ 100, <image>) — the number of cities and the number of roads in Berland, correspondingly. Next m lines contain pairs of integers vi, ui (1 ≤ vi, ui ≤ n, vi ≠ ui) — the numbers of cities that are connected by the i-th road. The numbers on a line are separated by a space.
It is guaranteed that each pair of cities is connected with no more than one road and that it is possible to get from any city to any other one along Berland roads.
Output
Print the maximum possible value of the average number of safe roads among all shortest paths from the culture capital to the main one. The answer will be considered valid if its absolute or relative inaccuracy does not exceed 10 - 6.
Examples
Input
4 4
1 2
2 4
1 3
3 4
Output
1.000000000000
Input
11 14
1 2
1 3
2 4
3 4
4 5
4 6
5 11
6 11
1 8
8 9
9 7
11 7
1 10
10 4
Output
1.714285714286
Note
In the first sample you can put a police station in one of the capitals, then each path will have exactly one safe road. If we place the station not in the capital, then the average number of safe roads will also make <image>.
In the second sample we can obtain the maximum sought value if we put the station in city 4, then 6 paths will have 2 safe roads each, and one path will have 0 safe roads, so the answer will equal <image>.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long n, m;
vector<long long> g[110];
long long disfrom1[110], disfromn[110];
long long totpath[110], totpathn[110];
bool used[110];
void bfs1() {
queue<long long> q;
used[1] = 1;
q.push(1);
totpath[1] = 1;
while (!q.empty()) {
long long k = q.front();
q.pop();
for (int i = 0; i < g[k].size(); i++) {
long long to = g[k][i];
if (!used[to]) {
used[to] = 1;
q.push(to);
disfrom1[to] = disfrom1[k] + 1;
}
if (disfrom1[to] == disfrom1[k] + 1) {
totpath[to] += totpath[k];
}
}
}
}
void bfsn() {
queue<long long> q;
q.push(n);
used[n] = 1;
totpathn[n] = 1;
while (!q.empty()) {
long long k = q.front();
q.pop();
for (int i = 0; i < g[k].size(); i++) {
long long to = g[k][i];
if (!used[to]) {
used[to] = 1;
q.push(to);
disfromn[to] = disfromn[k] + 1;
}
if (disfromn[to] == disfromn[k] + 1) {
totpathn[to] += totpathn[k];
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m;
for (int i = 0; i < m; i++) {
long long a, b;
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
bfs1();
memset(used, 0, sizeof used);
bfsn();
long long tt = totpath[n];
double sol = 1;
for (int i = 1; i <= n; i++) {
long long tn1 = 0;
long long tnn = 0;
long long mm1 = disfrom1[n] + 10;
long long mmn = disfromn[1] + 10;
for (int j = 0; j < g[i].size(); j++) {
long long to = g[i][j];
mm1 = min(mm1, disfrom1[to]);
mmn = min(mmn, disfromn[to]);
}
if (mm1 + mmn + 2 == disfrom1[n]) {
for (int j = 0; j < g[i].size(); j++) {
long long to = g[i][j];
if (disfrom1[to] == mm1) {
tn1 += totpath[to];
} else if (disfromn[to] == mmn) {
tnn += totpathn[to];
}
}
long long tp = tn1 * tnn;
sol = max(sol, (tp * 2.0) / tt);
}
}
cout << setprecision(8) << fixed;
cout << sol << endl;
return 0;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
Two boys decided to compete in text typing on the site "Key races". During the competition, they have to type a text consisting of s characters. The first participant types one character in v1 milliseconds and has ping t1 milliseconds. The second participant types one character in v2 milliseconds and has ping t2 milliseconds.
If connection ping (delay) is t milliseconds, the competition passes for a participant as follows:
1. Exactly after t milliseconds after the start of the competition the participant receives the text to be entered.
2. Right after that he starts to type it.
3. Exactly t milliseconds after he ends typing all the text, the site receives information about it.
The winner is the participant whose information on the success comes earlier. If the information comes from both participants at the same time, it is considered that there is a draw.
Given the length of the text and the information about participants, determine the result of the game.
Input
The first line contains five integers s, v1, v2, t1, t2 (1 ≤ s, v1, v2, t1, t2 ≤ 1000) — the number of characters in the text, the time of typing one character for the first participant, the time of typing one character for the the second participant, the ping of the first participant and the ping of the second participant.
Output
If the first participant wins, print "First". If the second participant wins, print "Second". In case of a draw print "Friendship".
Examples
Input
5 1 2 1 2
Output
First
Input
3 3 1 1 1
Output
Second
Input
4 5 3 1 5
Output
Friendship
Note
In the first example, information on the success of the first participant comes in 7 milliseconds, of the second participant — in 14 milliseconds. So, the first wins.
In the second example, information on the success of the first participant comes in 11 milliseconds, of the second participant — in 5 milliseconds. So, the second wins.
In the third example, information on the success of the first participant comes in 22 milliseconds, of the second participant — in 22 milliseconds. So, it is be a draw.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long int Maxn3 = 1e3 + 10;
const long long int Maxn4 = 1e4 + 10;
const long long int Maxn5 = 1e5 + 10;
const long long int Maxn6 = 1e6 + 10;
const long long int Maxn7 = 1e7 + 10;
const long long int Maxn8 = 1e8 + 10;
const long long int Maxn9 = 1e9 + 10;
const long long int Maxn18 = 1e18 + 10;
const long long int Mod1 = 1e7 + 7;
const long long int Mod2 = 1e9 + 7;
const long long int LLMax = LLONG_MAX;
const long long int LLMin = LLONG_MIN;
const long long int INTMax = INT_MAX;
const long long int INTMin = INT_MIN;
long long int mn = LLMax, mx = LLMin;
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
long long int s, v1, v2, t1, t2;
cin >> s >> v1 >> v2 >> t1 >> t2;
int a = s * v1 + 2 * t1;
int b = s * v2 + 2 * t2;
if (a < b)
cout << "First\n";
else if (a > b)
cout << "Second\n";
else
cout << "Friendship\n";
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
Kolya is developing an economy simulator game. His most favourite part of the development process is in-game testing. Once he was entertained by the testing so much, that he found out his game-coin score become equal to 0.
Kolya remembers that at the beginning of the game his game-coin score was equal to n and that he have bought only some houses (for 1 234 567 game-coins each), cars (for 123 456 game-coins each) and computers (for 1 234 game-coins each).
Kolya is now interested, whether he could have spent all of his initial n game-coins buying only houses, cars and computers or there is a bug in the game. Formally, is there a triple of non-negative integers a, b and c such that a × 1 234 567 + b × 123 456 + c × 1 234 = n?
Please help Kolya answer this question.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 109) — Kolya's initial game-coin score.
Output
Print "YES" (without quotes) if it's possible that Kolya spent all of his initial n coins buying only houses, cars and computers. Otherwise print "NO" (without quotes).
Examples
Input
1359257
Output
YES
Input
17851817
Output
NO
Note
In the first sample, one of the possible solutions is to buy one house, one car and one computer, spending 1 234 567 + 123 456 + 1234 = 1 359 257 game-coins in total.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int GCDFast(int a, int b) {
while (b) b ^= a ^= b ^= a %= b;
return a;
}
int dx[8] = {-1, 0, 1, 0, -1, 1, 1, -1};
int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int GCD(int b, int a) {
if (a == 0) return b;
return GCD(a, b % a);
}
long long getLcm(long long a, long long b) {
long long c = a / gcd(a, b);
return b * c;
}
bool mysort(int a, int b) {
if (a > b) return true;
return false;
}
long long data[100005], length;
void binary(int index, string str) {
if (length == index) {
cout << str << "\n";
for (int i = 0; i < length; i++) {
if (str[i] == '1') cout << data[i];
}
cout << "\n";
return;
}
binary(index + 1, str + '0');
binary(index + 1, str + '1');
}
int main() {
long long n, i, j, k, result = 0, temp, m;
long long x, y, z, sum, test_case, ans, len;
string name;
bool check;
while (cin >> n) {
check = false;
for (i = 0; i <= n && !check; i += 1234567) {
for (j = 0; j <= n; j += 123456) {
x = n - i - j;
if (x >= 0 && x % 1234 == 0)
check = true;
else if (x < 0)
break;
}
}
if (check)
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
Polycarpus got hold of a family tree. The found tree describes the family relations of n people, numbered from 1 to n. Every person in this tree has at most one direct ancestor. Also, each person in the tree has a name, the names are not necessarily unique.
We call the man with a number a a 1-ancestor of the man with a number b, if the man with a number a is a direct ancestor of the man with a number b.
We call the man with a number a a k-ancestor (k > 1) of the man with a number b, if the man with a number b has a 1-ancestor, and the man with a number a is a (k - 1)-ancestor of the 1-ancestor of the man with a number b.
In the tree the family ties do not form cycles. In other words there isn't a person who is his own direct or indirect ancestor (that is, who is an x-ancestor of himself, for some x, x > 0).
We call a man with a number a the k-son of the man with a number b, if the man with a number b is a k-ancestor of the man with a number a.
Polycarpus is very much interested in how many sons and which sons each person has. He took a piece of paper and wrote m pairs of numbers vi, ki. Help him to learn for each pair vi, ki the number of distinct names among all names of the ki-sons of the man with number vi.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 105) — the number of people in the tree. Next n lines contain the description of people in the tree. The i-th line contains space-separated string si and integer ri (0 ≤ ri ≤ n), where si is the name of the man with a number i, and ri is either the number of the direct ancestor of the man with a number i or 0, if the man with a number i has no direct ancestor.
The next line contains a single integer m (1 ≤ m ≤ 105) — the number of Polycarpus's records. Next m lines contain space-separated pairs of integers. The i-th line contains integers vi, ki (1 ≤ vi, ki ≤ n).
It is guaranteed that the family relationships do not form cycles. The names of all people are non-empty strings, consisting of no more than 20 lowercase English letters.
Output
Print m whitespace-separated integers — the answers to Polycarpus's records. Print the answers to the records in the order, in which the records occur in the input.
Examples
Input
6
pasha 0
gerald 1
gerald 1
valera 2
igor 3
olesya 1
5
1 1
1 2
1 3
3 1
6 1
Output
2
2
0
1
0
Input
6
valera 0
valera 1
valera 1
gerald 0
valera 4
kolya 4
7
1 1
1 2
2 1
2 2
4 1
5 1
6 1
Output
1
0
0
0
2
0
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[100010];
vector<pair<int, int> > point[100010];
map<pair<int, int>, int> vis;
int n, v, k, depth[100010], pos[100010][2], tot;
char s[100010][23];
void Dfs(int k, int d) {
pos[k][0] = ++tot;
point[d].push_back(make_pair(tot, k));
depth[k] = d;
for (vector<int>::iterator p = adj[k].begin(); p != adj[k].end(); ++p) {
Dfs(*p, d + 1);
}
pos[k][1] = ++tot;
}
int solve() {
if (vis[make_pair(v, k)]) return vis[make_pair(v, k)] - 1;
vector<pair<int, int> >::iterator l, r;
set<string> str;
l = lower_bound(point[depth[v] + k].begin(), point[depth[v] + k].end(),
make_pair(pos[v][0], 100010));
r = lower_bound(point[depth[v] + k].begin(), point[depth[v] + k].end(),
make_pair(pos[v][1], 0));
for (vector<pair<int, int> >::iterator p = l; p != r; ++p) {
str.insert(s[(*p).second]);
}
return (vis[make_pair(v, k)] = str.size() + 1) - 1;
}
int main() {
int p, m, i;
scanf("%d", &n);
for (i = 1; i <= n; ++i) {
scanf("%s%d", &s[i], &p);
adj[p].push_back(i);
}
Dfs(0, 0);
scanf("%d", &m);
while (m--) {
scanf("%d%d", &v, &k);
printf("%d\n", solve());
}
return 0;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
Vasily has a number a, which he wants to turn into a number b. For this purpose, he can do two types of operations:
* multiply the current number by 2 (that is, replace the number x by 2·x);
* append the digit 1 to the right of current number (that is, replace the number x by 10·x + 1).
You need to help Vasily to transform the number a into the number b using only the operations described above, or find that it is impossible.
Note that in this task you are not required to minimize the number of operations. It suffices to find any way to transform a into b.
Input
The first line contains two positive integers a and b (1 ≤ a < b ≤ 109) — the number which Vasily has and the number he wants to have.
Output
If there is no way to get b from a, print "NO" (without quotes).
Otherwise print three lines. On the first line print "YES" (without quotes). The second line should contain single integer k — the length of the transformation sequence. On the third line print the sequence of transformations x1, x2, ..., xk, where:
* x1 should be equal to a,
* xk should be equal to b,
* xi should be obtained from xi - 1 using any of two described operations (1 < i ≤ k).
If there are multiple answers, print any of them.
Examples
Input
2 162
Output
YES
5
2 4 8 81 162
Input
4 42
Output
NO
Input
100 40021
Output
YES
5
100 200 2001 4002 40021
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long finnal, arr[100000], prof = 0;
bool done = false;
void expandir(long long a) {
if (done == true) return;
arr[prof] = a;
prof++;
long long opc1 = 2 * a;
long long opc2 = a * 10 + 1;
if (a > finnal) {
prof--;
return;
}
if (a == finnal) {
cout << "YES" << endl;
cout << prof << endl;
for (int i = 0; i < prof; i++) cout << arr[i] << " ";
done = true;
} else {
expandir(opc1);
expandir(opc2);
}
prof--;
}
int main() {
long long a;
cin >> a >> finnal;
expandir(a);
if (done == false) {
cout << "NO" << endl;
}
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
Barney lives in country USC (United States of Charzeh). USC has n cities numbered from 1 through n and n - 1 roads between them. Cities and roads of USC form a rooted tree (Barney's not sure why it is rooted). Root of the tree is the city number 1. Thus if one will start his journey from city 1, he can visit any city he wants by following roads.
<image>
Some girl has stolen Barney's heart, and Barney wants to find her. He starts looking for in the root of the tree and (since he is Barney Stinson not a random guy), he uses a random DFS to search in the cities. A pseudo code of this algorithm is as follows:
let starting_time be an array of length n
current_time = 0
dfs(v):
current_time = current_time + 1
starting_time[v] = current_time
shuffle children[v] randomly (each permutation with equal possibility)
// children[v] is vector of children cities of city v
for u in children[v]:
dfs(u)
As told before, Barney will start his journey in the root of the tree (equivalent to call dfs(1)).
Now Barney needs to pack a backpack and so he wants to know more about his upcoming journey: for every city i, Barney wants to know the expected value of starting_time[i]. He's a friend of Jon Snow and knows nothing, that's why he asked for your help.
Input
The first line of input contains a single integer n (1 ≤ n ≤ 105) — the number of cities in USC.
The second line contains n - 1 integers p2, p3, ..., pn (1 ≤ pi < i), where pi is the number of the parent city of city number i in the tree, meaning there is a road between cities numbered pi and i in USC.
Output
In the first and only line of output print n numbers, where i-th number is the expected value of starting_time[i].
Your answer for each city will be considered correct if its absolute or relative error does not exceed 10 - 6.
Examples
Input
7
1 2 1 1 4 4
Output
1.0 4.0 5.0 3.5 4.5 5.0 5.0
Input
12
1 1 2 2 4 4 3 3 1 10 8
Output
1.0 5.0 5.5 6.5 7.5 8.0 8.0 7.0 7.5 6.5 7.5 8.0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void cmax(T& a, T b) {
a = max(a, b);
}
template <typename T>
void cmin(T& a, T b) {
a = min(a, b);
}
bool RD(void) { return true; }
bool RD(int& a) { return scanf("%d", &a) == 1; }
bool RD(long long& a) { return scanf("%lld", &a) == 1; }
bool RD(double& a) { return scanf("%lf", &a) == 1; }
bool RD(char& a) { return scanf(" %c", &a) == 1; }
bool RD(char* a) { return scanf("%s", a) == 1; }
template <typename T, typename... TT>
bool RD(T& a, TT&... b) {
return RD(a) && RD(b...);
}
const int maxn = 1.12e5;
vector<int> g[maxn];
int sz[maxn];
double e[maxn];
void getsz(int p, int u) {
sz[u] = 1;
for (int v : g[u])
if (v != p) {
getsz(u, v);
sz[u] += sz[v];
}
}
void calc(int p, int u) {
for (int v : g[u])
if (v != p) {
e[v] = e[u] + (sz[u] - 1 - sz[v]) / 2.0 + 1.0;
calc(u, v);
}
}
int main() {
int n;
RD(n);
for (int i = (2), __e = (n + 1); i < __e; ++i) {
int p;
RD(p);
g[i].push_back(p);
g[p].push_back(i);
}
getsz(0, 1);
e[1] = 1.0;
calc(0, 1);
for (int i = (1), __e = (n + 1); i < __e; ++i)
printf("%.15lf%c", e[i], " \n"[i == n]);
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
You are given the following points with integer coordinates on the plane: M0, A0, A1, ..., An - 1, where n is odd number. Now we define the following infinite sequence of points Mi: Mi is symmetric to Mi - 1 according <image> (for every natural number i). Here point B is symmetric to A according M, if M is the center of the line segment AB. Given index j find the point Mj.
Input
On the first line you will be given an integer n (1 ≤ n ≤ 105), which will be odd, and j (1 ≤ j ≤ 1018), where j is the index of the desired point. The next line contains two space separated integers, the coordinates of M0. After that n lines follow, where the i-th line contain the space separated integer coordinates of the point Ai - 1. The absolute values of all input coordinates will not be greater then 1000.
Output
On a single line output the coordinates of Mj, space separated.
Examples
Input
3 4
0 0
1 1
2 3
-5 3
Output
14 0
Input
3 1
5 5
1000 1000
-1000 1000
3 100
Output
1995 1995
### Response
```cpp
#include <bits/stdc++.h>
struct point {
int x, y;
} a[100010];
int main() {
int n, x, y;
long long t;
scanf("%d%I64d", &n, &t);
scanf("%d%d", &x, &y);
for (int i = 0; i < n; i++) scanf("%d%d", &a[i].x, &a[i].y);
int r = t % (2 * n);
for (int i = 0; i < r; i++) x = 2 * a[i % n].x - x, y = 2 * a[i % n].y - y;
printf("%d %d", x, y);
}
``` |
### Prompt
Generate a CPP solution to the following problem:
Snuke found a record of a tree with N vertices in ancient ruins. The findings are as follows:
* The vertices of the tree were numbered 1,2,...,N, and the edges were numbered 1,2,...,N-1.
* Edge i connected Vertex a_i and b_i.
* The length of each edge was an integer between 1 and 10^{18} (inclusive).
* The sum of the shortest distances from Vertex i to Vertex 1,...,N was s_i.
From the information above, restore the length of each edge. The input guarantees that it is possible to determine the lengths of the edges consistently with the record. Furthermore, it can be proved that the length of each edge is uniquely determined in such a case.
Constraints
* 2 \leq N \leq 10^{5}
* 1 \leq a_i,b_i \leq N
* 1 \leq s_i \leq 10^{18}
* The given graph is a tree.
* All input values are integers.
* It is possible to consistently restore the lengths of the edges.
* In the restored graph, the length of each edge is an integer between 1 and 10^{18} (inclusive).
Input
Input is given from Standard Input in the following format:
N
a_1 b_1
:
a_{N-1} b_{N-1}
s_1 s_2 ... s_{N}
Output
Print N-1 lines. The i-th line must contain the length of Edge i.
Examples
Input
4
1 2
2 3
3 4
8 6 6 8
Output
1
2
1
Input
5
1 2
1 3
1 4
1 5
10 13 16 19 22
Output
1
2
3
4
Input
15
9 10
9 15
15 4
4 13
13 2
13 11
2 14
13 6
11 1
1 12
12 3
12 7
2 5
14 8
1154 890 2240 883 2047 2076 1590 1104 1726 1791 1091 1226 841 1000 901
Output
5
75
2
6
7
50
10
95
9
8
78
28
89
8
### Response
```cpp
#include<cstdio>
#include<algorithm>
#include<vector>
using namespace std;
int n, C[101000], ck, cc;
long long S[101000], R[101000], SS;
vector<int>E[101000], Num[101000];
void DFS(int a, int pp, int num) {
int i;
C[a] = 1;
for (i = 0; i < E[a].size(); i++) {
if (E[a][i] == pp)continue;
DFS(E[a][i], a, Num[a][i]);
C[a] += C[E[a][i]];
}
if (pp) {
if (C[a] * 2 == n)ck = num, cc = C[a];
else {
R[num] = (S[a] - S[pp]) / (n - C[a] * 2);
SS -= C[a] * R[num];
}
}
}
int main() {
int i, a, b;
scanf("%d", &n);
for (i = 1; i < n; i++) {
scanf("%d%d", &a, &b);
E[a].push_back(b);
E[b].push_back(a);
Num[a].push_back(i);
Num[b].push_back(i);
}
for (i = 1; i <= n; i++)scanf("%lld", &S[i]);
SS = S[1];
DFS(1, 0, -1);
if (ck)R[ck] = SS / cc;
for (i = 1; i < n; i++)printf("%lld\n", R[i]);
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
Have you ever played Hanabi? If not, then you've got to try it out! This problem deals with a simplified version of the game.
Overall, the game has 25 types of cards (5 distinct colors and 5 distinct values). Borya is holding n cards. The game is somewhat complicated by the fact that everybody sees Borya's cards except for Borya himself. Borya knows which cards he has but he knows nothing about the order they lie in. Note that Borya can have multiple identical cards (and for each of the 25 types of cards he knows exactly how many cards of this type he has).
The aim of the other players is to achieve the state when Borya knows the color and number value of each of his cards. For that, other players can give him hints. The hints can be of two types: color hints and value hints.
A color hint goes like that: a player names some color and points at all the cards of this color.
Similarly goes the value hint. A player names some value and points at all the cards that contain the value.
Determine what minimum number of hints the other players should make for Borya to be certain about each card's color and value.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the number of Borya's cards. The next line contains the descriptions of n cards. The description of each card consists of exactly two characters. The first character shows the color (overall this position can contain five distinct letters — R, G, B, Y, W). The second character shows the card's value (a digit from 1 to 5). Borya doesn't know exact order of the cards they lie in.
Output
Print a single integer — the minimum number of hints that the other players should make.
Examples
Input
2
G3 G3
Output
0
Input
4
G4 R4 R3 B3
Output
2
Input
5
B1 Y1 W1 G1 R1
Output
4
Note
In the first sample Borya already knows for each card that it is a green three.
In the second sample we can show all fours and all red cards.
In the third sample you need to make hints about any four colors.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n;
bool ok[6][6];
set<char> s1[6];
set<char> s2[6];
vector<int> v1[6], v2[6];
char col[105];
char num[105];
int hint[105];
int ans;
int main() {
cin >> n;
ans = n;
for (int i = 1; i <= n; i++) {
cin >> col[i] >> num[i];
if (col[i] == 'R') {
col[i] = 'A';
} else if (col[i] == 'G') {
col[i] = 'B';
} else if (col[i] == 'B') {
col[i] = 'C';
} else if (col[i] == 'Y') {
col[i] = 'D';
} else {
col[i] = 'E';
}
v1[col[i] - 'A' + 1].push_back(i);
v2[num[i] - '0'].push_back(i);
}
for (int msk = 0; msk < (1 << 10); msk++) {
int t = msk;
int pl = 0;
int cnt = 0;
for (int i = 1; i <= 5; i++) {
s1[i].clear();
s2[i].clear();
}
memset(hint, 0, sizeof(hint));
while (t) {
pl++;
if (t % 2) {
cnt++;
if (pl <= 5) {
for (int i = 0; i < v1[pl].size(); i++) {
hint[v1[pl][i]]++;
s1[pl].insert(num[v1[pl][i]]);
}
} else {
for (int i = 0; i < v2[pl - 5].size(); i++) {
hint[v2[pl - 5][i]]++;
s2[pl - 5].insert(col[v2[pl - 5][i]]);
}
}
}
t /= 2;
}
set<pair<char, char> > S;
for (int i = 1; i <= n; i++) {
if (hint[i] == 2) {
s1[col[i] - 'A' + 1].erase(num[i]);
s2[num[i] - '0'].erase(col[i]);
} else if (hint[i] == 0) {
S.insert(make_pair(col[i], num[i]));
}
}
bool flag = true;
for (int i = 1; i <= 5; i++) {
if (s1[i].size() > 1 || s2[i].size() > 1) {
flag = false;
break;
}
}
if (S.size() > 1) {
flag = false;
}
if (flag) {
ans = min(ans, cnt);
}
}
cout << ans;
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
In the town of Aalam-Aara (meaning the Light of the Earth), previously there was no crime, no criminals but as the time progressed, sins started creeping into the hearts of once righteous people. Seeking solution to the problem, some of the elders found that as long as the corrupted part of population was kept away from the uncorrupted part, the crimes could be stopped. So, they are trying to set up a compound where they can keep the corrupted people. To ensure that the criminals don't escape the compound, a watchtower needs to be set up, so that they can be watched.
Since the people of Aalam-Aara aren't very rich, they met up with a merchant from some rich town who agreed to sell them a land-plot which has already a straight line fence AB along which a few points are set up where they can put up a watchtower. Your task is to help them find out the number of points on that fence where the tower can be put up, so that all the criminals can be watched from there. Only one watchtower can be set up. A criminal is watchable from the watchtower if the line of visibility from the watchtower to him doesn't cross the plot-edges at any point between him and the tower i.e. as shown in figure 1 below, points X, Y, C and A are visible from point B but the points E and D are not.
<image> Figure 1 <image> Figure 2
Assume that the land plot is in the shape of a polygon and coordinate axes have been setup such that the fence AB is parallel to x-axis and the points where the watchtower can be set up are the integer points on the line. For example, in given figure 2, watchtower can be setup on any of five integer points on AB i.e. (4, 8), (5, 8), (6, 8), (7, 8) or (8, 8). You can assume that no three consecutive points are collinear and all the corner points other than A and B, lie towards same side of fence AB. The given polygon doesn't contain self-intersections.
Input
The first line of the test case will consist of the number of vertices n (3 ≤ n ≤ 1000).
Next n lines will contain the coordinates of the vertices in the clockwise order of the polygon. On the i-th line are integers xi and yi (0 ≤ xi, yi ≤ 106) separated by a space.
The endpoints of the fence AB are the first two points, (x1, y1) and (x2, y2).
Output
Output consists of a single line containing the number of points where the watchtower can be set up.
Examples
Input
5
4 8
8 8
9 4
4 0
0 4
Output
5
Input
5
4 8
5 8
5 4
7 4
2 2
Output
0
Note
Figure 2 shows the first test case. All the points in the figure are watchable from any point on fence AB. Since, AB has 5 integer coordinates, so answer is 5.
For case two, fence CD and DE are not completely visible, thus answer is 0.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int turn2(std::complex<double> a, std::complex<double> b,
std::complex<double> c) {
double x = imag((a - b) * conj(c - b));
return x < 0 ? -1 : x > 0;
}
std::complex<double> omega(std::complex<double> x, std::complex<double> y) {
return conj(x - y) / (x - y);
}
std::complex<double> rho(std::complex<double> x, std::complex<double> y) {
return (conj(x) * y - x * conj(y)) / (x - y);
}
std::complex<double> intersection(std::complex<double> a,
std::complex<double> b,
std::complex<double> c,
std::complex<double> d) {
return (rho(a, b) - rho(c, d)) / (omega(a, b) - omega(c, d));
}
bool parallel(std::complex<double> a, std::complex<double> b,
std::complex<double> c, std::complex<double> d) {
return imag((a - b) * conj(c - d)) == 0;
}
double EPS = 1e-8;
double l = -1e20;
double r = 1e20;
vector<std::complex<double> > x;
int n;
int turn;
std::complex<double> I = std::complex<double>(0, 1);
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
x.push_back(std::complex<double>(a, b));
}
if (real(x[0]) > real(x[1])) {
for (int i = 0; i < n; i++) x[i] *= -1;
}
turn = turn2(x[0], x[1], x[2]);
for (int i = 2; i + 1 < n; i++) {
if (parallel(x[0], x[1], x[i], x[i + 1])) {
if (turn2(x[i], x[i + 1], x[i + 1] + I) != turn) {
r = -1e20;
l = 1e20;
}
} else {
std::complex<double> s = intersection(x[0], x[1], x[i], x[i + 1]);
if (turn2(x[i], x[i + 1], s + 1.0) == turn) {
l = max(l, real(s));
} else {
r = min(r, real(s));
}
}
}
l = max(l, real(x[0]));
r = min(r, real(x[1]));
if (r - l >= -EPS) {
printf("%d\n", (int)(floor(r + EPS) - ceil(l - EPS)) + 1);
} else {
printf("0\n");
}
return 0;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
There is a rooted tree (see Notes) with N vertices numbered 1 to N. Each of the vertices, except the root, has a directed edge coming from its parent. Note that the root may not be Vertex 1.
Takahashi has added M new directed edges to this graph. Each of these M edges, u \rightarrow v, extends from some vertex u to its descendant v.
You are given the directed graph with N vertices and N-1+M edges after Takahashi added edges. More specifically, you are given N-1+M pairs of integers, (A_1, B_1), ..., (A_{N-1+M}, B_{N-1+M}), which represent that the i-th edge extends from Vertex A_i to Vertex B_i.
Restore the original rooted tree.
Constraints
* 3 \leq N
* 1 \leq M
* N + M \leq 10^5
* 1 \leq A_i, B_i \leq N
* A_i \neq B_i
* If i \neq j, (A_i, B_i) \neq (A_j, B_j).
* The graph in input can be obtained by adding M edges satisfying the condition in the problem statement to a rooted tree with N vertices.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
:
A_{N-1+M} B_{N-1+M}
Output
Print N lines. In the i-th line, print `0` if Vertex i is the root of the original tree, and otherwise print the integer representing the parent of Vertex i in the original tree.
Note that it can be shown that the original tree is uniquely determined.
Examples
Input
3 1
1 2
1 3
2 3
Output
0
1
2
Input
6 3
2 1
2 3
4 1
4 2
6 1
2 6
4 6
6 5
Output
6
4
2
0
6
2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int N,M;
int root;
vector<int> G[100010];
vector<bool> rootf(100010,true);
vector<int> tt(100010,0);
vector<int> ans(100010,-1);
queue<int> que;
int main(){
cin >> N >> M;
for(int i=0;i<N+M-1;i++){
int s,t;
scanf("%d%d",&s,&t);
G[s].push_back(t);
rootf.at(t)=false;
tt.at(t)++;
}
for(int i=1;i<=N;i++)if(rootf.at(i))root=i;
ans.at(root)=0;
que.push(root);
while(que.empty()==0){
int s=que.front();
que.pop();
for(auto t:G[s]){
ans.at(t)=s;
tt.at(t)--;
if(tt.at(t)==0)que.push(t);
}
}
for(int i=1;i<=N;i++)printf("%d\n",ans.at(i));
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
Monocarp and Bicarp live in Berland, where every bus ticket consists of n digits (n is an even number). During the evening walk Monocarp and Bicarp found a ticket where some of the digits have been erased. The number of digits that have been erased is even.
Monocarp and Bicarp have decided to play a game with this ticket. Monocarp hates happy tickets, while Bicarp collects them. A ticket is considered happy if the sum of the first n/2 digits of this ticket is equal to the sum of the last n/2 digits.
Monocarp and Bicarp take turns (and Monocarp performs the first of them). During each turn, the current player must replace any erased digit with any digit from 0 to 9. The game ends when there are no erased digits in the ticket.
If the ticket is happy after all erased digits are replaced with decimal digits, then Bicarp wins. Otherwise, Monocarp wins. You have to determine who will win if both players play optimally.
Input
The first line contains one even integer n (2 ≤ n ≤ 2 ⋅ 10^{5}) — the number of digits in the ticket.
The second line contains a string of n digits and "?" characters — the ticket which Monocarp and Bicarp have found. If the i-th character is "?", then the i-th digit is erased. Note that there may be leading zeroes. The number of "?" characters is even.
Output
If Monocarp wins, print "Monocarp" (without quotes). Otherwise print "Bicarp" (without quotes).
Examples
Input
4
0523
Output
Bicarp
Input
2
??
Output
Bicarp
Input
8
?054??0?
Output
Bicarp
Input
6
???00?
Output
Monocarp
Note
Since there is no question mark in the ticket in the first example, the winner is determined before the game even starts, and it is Bicarp.
In the second example, Bicarp also wins. After Monocarp chooses an erased digit and replaces it with a new one, Bicap can choose another position with an erased digit and replace it with the same digit, so the ticket is happy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
string s;
cin >> s;
long long int x = 0, sum = 0;
for (int i = 0; i < n / 2; i++) {
if (s[i] == '?')
x++;
else
sum += s[i] - '0';
}
for (int i = n / 2; i < n; i++) {
if (s[i] == '?')
x--;
else
sum -= s[i] - '0';
}
if (2 * sum == -1 * 9 * x) {
cout << "Bicarp";
return 0;
}
cout << "Monocarp";
return 0;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
Chief Judge's log, stardate 48642.5. We have decided to make a problem from elementary number theory. The problem looks like finding all prime factors of a positive integer, but it is not.
A positive integer whose remainder divided by 7 is either 1 or 6 is called a 7N+{1,6} number. But as it is hard to pronounce, we shall call it a Monday-Saturday number.
For Monday-Saturday numbers a and b, we say a is a Monday-Saturday divisor of b if there exists a Monday-Saturday number x such that ax = b. It is easy to show that for any Monday-Saturday numbers a and b, it holds that a is a Monday-Saturday divisor of b if and only if a is a divisor of b in the usual sense.
We call a Monday-Saturday number a Monday-Saturday prime if it is greater than 1 and has no Monday-Saturday divisors other than itself and 1. A Monday-Saturday number which is a prime in the usual sense is a Monday-Saturday prime but the converse does not always hold. For example, 27 is a Monday-Saturday prime although it is not a prime in the usual sense. We call a Monday-Saturday prime which is a Monday-Saturday divisor of a Monday-Saturday number a a Monday-Saturday prime factor of a. For example, 27 is one of the Monday-Saturday prime factors of 216, since 27 is a Monday-Saturday prime and 216 = 27 × 8 holds.
Any Monday-Saturday number greater than 1 can be expressed as a product of one or more Monday-Saturday primes. The expression is not always unique even if differences in order are ignored. For example, 216 = 6 × 6 × 6 = 8 × 27 holds.
Our contestants should write a program that outputs all Monday-Saturday prime factors of each input Monday-Saturday number.
Input
The input is a sequence of lines each of which contains a single Monday-Saturday number. Each Monday-Saturday number is greater than 1 and less than 300000 (three hundred thousand). The end of the input is indicated by a line containing a single digit 1.
Output
For each input Monday-Saturday number, it should be printed, followed by a colon `:' and the list of its Monday-Saturday prime factors on a single line. Monday-Saturday prime factors should be listed in ascending order and each should be preceded by a space. All the Monday-Saturday prime factors should be printed only once even if they divide the input Monday-Saturday number more than once.
Sample Input
205920
262144
262200
279936
299998
1
Output for the Sample Input
205920: 6 8 13 15 20 22 55 99
262144: 8
262200: 6 8 15 20 50 57 69 76 92 190 230 475 575 874 2185
279936: 6 8 27
299998: 299998
Example
Input
205920
262144
262200
279936
299998
1
Output
205920: 6 8 13 15 20 22 55 99
262144: 8
262200: 6 8 15 20 50 57 69 76 92 190 230 475 575 874 2185
279936: 6 8 27
299998: 299998
### Response
```cpp
#include <iostream>
#include <vector>
#include <algorithm>
#define LIM 300020
using namespace std;
int main(){
int n;
bool isprime[LIM]={0};
vector<int> primes;
for(int i=2; i<LIM; ++i)
isprime[i]=true;
for(int i=2; i*i<LIM; ++i){
if(isprime[i] && (i%7==1 || i%7==6)){
for(int j=i; i*j<LIM; j++){
if(j%7==1 || j%7==6){
isprime[i*j]=false;
}
}
}
}
for(int i=0; i<LIM; ++i){
if(isprime[i] && (i%7==1 || i%7==6))
primes.push_back(i);
}
while(cin>>n, n>1){
cout << n << ":";
for(int i=0; i<primes.size(); ++i){
if(n%primes[i]==0)
cout << " " << primes[i];
}
cout << endl;
}
return 0;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
There is a house with n flats situated on the main street of Berlatov. Vova is watching this house every night. The house can be represented as an array of n integer numbers a_1, a_2, ..., a_n, where a_i = 1 if in the i-th flat the light is on and a_i = 0 otherwise.
Vova thinks that people in the i-th flats are disturbed and cannot sleep if and only if 1 < i < n and a_{i - 1} = a_{i + 1} = 1 and a_i = 0.
Vova is concerned by the following question: what is the minimum number k such that if people from exactly k pairwise distinct flats will turn off the lights then nobody will be disturbed? Your task is to find this number k.
Input
The first line of the input contains one integer n (3 ≤ n ≤ 100) — the number of flats in the house.
The second line of the input contains n integers a_1, a_2, ..., a_n (a_i ∈ \{0, 1\}), where a_i is the state of light in the i-th flat.
Output
Print only one integer — the minimum number k such that if people from exactly k pairwise distinct flats will turn off the light then nobody will be disturbed.
Examples
Input
10
1 1 0 1 1 0 1 0 1 0
Output
2
Input
5
1 1 0 0 0
Output
0
Input
4
1 1 1 1
Output
0
Note
In the first example people from flats 2 and 7 or 4 and 7 can turn off the light and nobody will be disturbed. It can be shown that there is no better answer in this example.
There are no disturbed people in second and third examples.
### 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 i, j, k, n, m, t, sum = 0, ans = 0;
bool f = 0, flag = 0;
string s;
cin >> n;
long long int a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
}
for (i = 1; i < n - 1; i++) {
if (a[i] == 0 && a[i - 1] == 1 && a[i + 1] == 1) {
a[i + 1] = 0;
sum++;
i++;
}
}
cout << sum << endl;
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
We call two numbers x and y similar if they have the same parity (the same remainder when divided by 2), or if |x-y|=1. For example, in each of the pairs (2, 6), (4, 3), (11, 7), the numbers are similar to each other, and in the pairs (1, 4), (3, 12), they are not.
You are given an array a of n (n is even) positive integers. Check if there is such a partition of the array into pairs that each element of the array belongs to exactly one pair and the numbers in each pair are similar to each other.
For example, for the array a = [11, 14, 16, 12], there is a partition into pairs (11, 12) and (14, 16). The numbers in the first pair are similar because they differ by one, and in the second pair because they are both even.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases. Then t test cases follow.
Each test case consists of two lines.
The first line contains an even positive integer n (2 ≤ n ≤ 50) — length of array a.
The second line contains n positive integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 100).
Output
For each test case print:
* YES if the such a partition exists,
* NO otherwise.
The letters in the words YES and NO can be displayed in any case.
Example
Input
7
4
11 14 16 12
2
1 8
4
1 1 1 1
4
1 2 5 6
2
12 13
6
1 6 3 10 5 8
6
1 12 3 10 5 8
Output
YES
NO
YES
YES
YES
YES
NO
Note
The first test case was explained in the statement.
In the second test case, the two given numbers are not similar.
In the third test case, any partition is suitable.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void test() {
int i, n, a, cnt = 0, c = 0;
vector<int> v;
cin >> n;
for (i = 0; i < n; ++i) {
cin >> a;
v.push_back(a);
}
sort(v.begin(), v.end(), greater<int>());
for (i = 0; i < n; ++i) {
if (v[i] % 2) cnt++;
}
if (cnt % 2 == 0) {
cout << "YES" << endl;
return;
}
for (i = 0; i < n - 1; ++i) {
if (v[i] - v[i + 1] == 1) c++;
}
if (c >= 1)
cout << "YES\n";
else
cout << "NO" << endl;
}
int main() {
int t;
cin >> t;
while (t--) test();
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
There is a sequence of length N: a = (a_1, a_2, ..., a_N). Here, each a_i is a non-negative integer.
Snuke can repeatedly perform the following operation:
* Let the XOR of all the elements in a be x. Select an integer i (1 ≤ i ≤ N) and replace a_i with x.
Snuke's objective is to match a with another sequence b = (b_1, b_2, ..., b_N). Here, each b_i is a non-negative integer.
Determine whether the objective is achievable, and find the minimum necessary number of operations if the answer is positive.
Constraints
* 2 ≤ N ≤ 10^5
* a_i and b_i are integers.
* 0 ≤ a_i, b_i < 2^{30}
Input
Input is given from Standard Input in the following format:
N
a_1 a_2 ... a_N
b_1 b_2 ... b_N
Output
If the objective is achievable, print the minimum necessary number of operations. Otherwise, print `-1` instead.
Examples
Input
3
0 1 2
3 1 0
Output
2
Input
3
0 1 2
0 1 2
Output
0
Input
2
1 1
0 0
Output
-1
Input
4
0 1 2 3
1 0 3 2
Output
5
### Response
```cpp
#include<bits/stdc++.h>
#define pb push_back
using namespace std;
const int N=1e5+50;
int n,a[N],b[N],c[N],c2[N],m,ans;bool vis[N];
vector<int>v[N];
void dfs(int x){
vis[x]=1;
for(int i=0,y;i<v[x].size();i++)
if(!vis[y=v[x][i]])dfs(y);
}
int main(){
scanf("%d",&n);n++;
for(int i=1;i<n;i++)scanf("%d",&a[i]),a[n]^=a[i];
for(int i=1;i<n;i++)scanf("%d",&b[i]),b[n]^=b[i];
for(int i=1;i<=n;i++)c[i]=a[i],c2[i]=b[i];
sort(c+1,c+n+1);sort(c2+1,c2+n+1);
for(int i=1;i<=n;i++)if(c[i]!=c2[i])puts("-1"),exit(0);
m=unique(c+1,c+n+1)-c-1;
for(int i=1;i<=n;i++)a[i]=lower_bound(c+1,c+m+1,a[i])-c,b[i]=lower_bound(c+1,c+m+1,b[i])-c;
for(int i=1;i<=n;i++)if(a[i]!=b[i])v[a[i]].pb(b[i]),ans++;
for(int i=1;i<=m;i++)if(!vis[i]&&v[i].size())dfs(i),ans++;ans-=2;
if(a[n]==b[n]){
if(!v[a[n]].size())ans+=2;
else ans++;
}
cout<<ans;
return 0;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
The clique problem is one of the most well-known NP-complete problems. Under some simplification it can be formulated as follows. Consider an undirected graph G. It is required to find a subset of vertices C of the maximum size such that any two of them are connected by an edge in graph G. Sounds simple, doesn't it? Nobody yet knows an algorithm that finds a solution to this problem in polynomial time of the size of the graph. However, as with many other NP-complete problems, the clique problem is easier if you consider a specific type of a graph.
Consider n distinct points on a line. Let the i-th point have the coordinate xi and weight wi. Let's form graph G, whose vertices are these points and edges connect exactly the pairs of points (i, j), such that the distance between them is not less than the sum of their weights, or more formally: |xi - xj| ≥ wi + wj.
Find the size of the maximum clique in such graph.
Input
The first line contains the integer n (1 ≤ n ≤ 200 000) — the number of points.
Each of the next n lines contains two numbers xi, wi (0 ≤ xi ≤ 109, 1 ≤ wi ≤ 109) — the coordinate and the weight of a point. All xi are different.
Output
Print a single number — the number of vertexes in the maximum clique of the given graph.
Examples
Input
4
2 3
3 1
6 1
0 2
Output
3
Note
If you happen to know how to solve this problem without using the specific properties of the graph formulated in the problem statement, then you are able to get a prize of one million dollars!
The picture for the sample test.
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int x, w;
pair<int, int> m[N];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> x >> w;
m[i].first = x + w;
m[i].second = x - w;
}
sort(m, m + n);
int ans = 0;
int cnt = 0;
for (int i = 1; i < n; ++i) {
if (m[i].second >= m[ans].first) {
ans = i;
++cnt;
}
}
cout << cnt + 1;
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
This problem consists of two subproblems: for solving subproblem E1 you will receive 11 points, and for solving subproblem E2 you will receive 13 points.
A tree is an undirected connected graph containing no cycles. The distance between two nodes in an unweighted tree is the minimum number of edges that have to be traversed to get from one node to another.
You are given 3 trees that have to be united into a single tree by adding two edges between these trees. Each of these edges can connect any pair of nodes from two trees. After the trees are connected, the distances between all unordered pairs of nodes in the united tree should be computed. What is the maximum possible value of the sum of these distances?
Input
The first line contains three space-separated integers n1, n2, n3 — the number of vertices in the first, second, and third trees, respectively. The following n1 - 1 lines describe the first tree. Each of these lines describes an edge in the first tree and contains a pair of integers separated by a single space — the numeric labels of vertices connected by the edge. The following n2 - 1 lines describe the second tree in the same fashion, and the n3 - 1 lines after that similarly describe the third tree. The vertices in each tree are numbered with consecutive integers starting with 1.
The problem consists of two 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 E1 (11 points), the number of vertices in each tree will be between 1 and 1000, inclusive.
* In subproblem E2 (13 points), the number of vertices in each tree will be between 1 and 100000, inclusive.
Output
Print a single integer number — the maximum possible sum of distances between all pairs of nodes in the united tree.
Examples
Input
2 2 3
1 2
1 2
1 2
2 3
Output
56
Input
5 1 4
1 2
2 5
3 4
4 2
1 2
1 3
1 4
Output
151
Note
Consider the first test case. There are two trees composed of two nodes, and one tree with three nodes. The maximum possible answer is obtained if the trees are connected in a single chain of 7 vertices.
In the second test case, a possible choice of new edges to obtain the maximum answer is the following:
* Connect node 3 from the first tree to node 1 from the second tree;
* Connect node 2 from the third tree to node 1 from the second tree.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <class T>
void debug(T a, T b) {
;
}
template <class T>
void chmin(T& a, const T& b) {
if (a > b) a = b;
}
template <class T>
void chmax(T& a, const T& b) {
if (a < b) a = b;
}
namespace std {
template <class S, class T>
ostream& operator<<(ostream& out, const pair<S, T>& a) {
out << '(' << a.first << ',' << a.second << ')';
return out;
}
} // namespace std
long long int readL() {
long long int res;
scanf("%I64d", &res);
return res;
}
void printL(long long int res) { printf("%I64d", res); }
const int INF = 5e8;
struct Tree {
int e[200005], nxt[200005], begin[100005], cnt;
int n;
long long int totdist[100005];
int size[100005];
long long int sum_dist;
void getdist(int v, int p) {
size[v] = 1;
for (int it = begin[v]; ~it; it = nxt[it]) {
int to = e[it];
if (to == p) continue;
getdist(to, v);
size[v] += size[to];
totdist[v] += totdist[to];
}
totdist[v] += size[v] - 1;
}
void getdist2(int v, int p, long long int sum) {
for (int it = begin[v]; ~it; it = nxt[it]) {
int to = e[it];
if (to == p) continue;
getdist2(to, v,
sum + totdist[v] - (totdist[to] + size[to]) + n - size[to]);
}
totdist[v] += sum;
}
long long int maxdist;
void init(int n_) {
n = n_;
memset(begin, -1, sizeof(begin));
cnt = 0;
for (int i = 0; i < (n - 1); ++i) {
int a, b;
scanf("%d%d", &a, &b);
--a;
--b;
e[cnt] = b;
nxt[cnt] = begin[a];
begin[a] = cnt++;
e[cnt] = a;
nxt[cnt] = begin[b];
begin[b] = cnt++;
}
maxdist = sum_dist = 0;
getdist(0, -1);
getdist2(0, -1, 0);
for (int i = 0; i < (n); ++i) {
chmax(maxdist, totdist[i]);
sum_dist += totdist[i];
}
debug(totdist, totdist + n);
sum_dist /= 2;
}
long long int dis1, dis3;
int n1, n3;
int cut[100005];
long long int res;
pair<long long int, long long int> dfs(int v, int p, int d) {
pair<long long int, long long int> nxtt =
make_pair(totdist[v] * n1 + d * (long long int)n1 * n3,
totdist[v] * n3 + d * (long long int)n1 * n3);
chmax(res, nxtt.first + nxtt.second - 2LL * d * n1 * n3);
for (int it = begin[v]; ~it; it = nxt[it]) {
int to = e[it];
if (to == p) continue;
pair<long long int, long long int> nxt2 = dfs(to, v, d + 1);
chmax(res, nxtt.first + nxt2.second - 2LL * d * (long long int)n1 * n3);
chmax(res, nxtt.second + nxt2.first - 2LL * d * (long long int)n1 * n3);
chmax(nxtt.first, nxt2.first);
chmax(nxtt.second, nxt2.second);
}
return nxtt;
}
long long int query(long long int A, long long int B, int n1_, int n3_) {
;
;
dis1 = A;
dis3 = B;
n1 = n1_;
n3 = n3_;
memset((cut), 0, sizeof(cut));
res = 0;
dfs(0, -1, 0);
res += (dis1 + dis3) * n;
res += n1 * dis3;
res += n3 * dis1;
res += 2ll * n1 * n3;
res += 1ll * n1 * n;
res += 1ll * n * n3;
return res;
}
};
Tree T[3];
int n[3];
int main() {
cin >> n[0] >> n[1] >> n[2];
for (int i = 0; i < (3); ++i) {
T[i].init(n[i]);
}
int perm[3] = {0, 1, 2};
long long int res = 0, base = T[0].sum_dist + T[1].sum_dist + T[2].sum_dist;
do {
if (perm[0] > perm[2]) {
chmax(res, T[perm[1]].query(T[perm[0]].maxdist, T[perm[2]].maxdist,
n[perm[0]], n[perm[2]]));
}
} while (next_permutation(perm, perm + 3));
res += base;
cout << res << endl;
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
Today you are going to lead a group of elven archers to defend the castle that is attacked by an army of angry orcs. Three sides of the castle are protected by impassable mountains and the remaining side is occupied by a long wall that is split into n sections. At this moment there are exactly ai archers located at the i-th section of this wall. You know that archer who stands at section i can shoot orcs that attack section located at distance not exceeding r, that is all such sections j that |i - j| ≤ r. In particular, r = 0 means that archers are only capable of shooting at orcs who attack section i.
Denote as defense level of section i the total number of archers who can shoot at the orcs attacking this section. Reliability of the defense plan is the minimum value of defense level of individual wall section.
There is a little time left till the attack so you can't redistribute archers that are already located at the wall. However, there is a reserve of k archers that you can distribute among wall sections in arbitrary way. You would like to achieve maximum possible reliability of the defence plan.
Input
The first line of the input contains three integers n, r and k (1 ≤ n ≤ 500 000, 0 ≤ r ≤ n, 0 ≤ k ≤ 1018) — the number of sections of the wall, the maximum distance to other section archers can still shoot and the number of archers yet to be distributed along the wall. The second line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 109) — the current number of archers at each section.
Output
Print one integer — the maximum possible value of defense plan reliability, i.e. the maximum possible value of minimum defense level if we distribute k additional archers optimally.
Examples
Input
5 0 6
5 4 3 4 9
Output
5
Input
4 2 0
1 2 3 4
Output
6
Input
5 1 1
2 1 2 1 2
Output
3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 10;
const long long mod = 1e9 + 7;
const long double eps = 1e-10;
const int inf = 1e6;
int n, d;
long long k;
long long a[maxn];
long long ac[maxn];
long long bc[maxn];
long long b[maxn];
bool check(long long t) {
memset(b, 0, sizeof(b));
long long used = 0;
long long cur = 0;
for (int i = 0; i < n; ++i) {
cur += ac[i];
long long need = max(0ll, t - cur);
int addPos = i + d * 2;
cur += need;
used += need;
if (used > k) return false;
if (addPos < n) b[addPos] += need;
cur -= b[i];
cur -= bc[i];
}
return used <= k;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> d >> k;
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i < n; ++i) {
int lp = max(0, i - d);
int rp = min(n - 1, i + d);
ac[lp] += a[i];
bc[rp] += a[i];
}
long long l = *min_element(a, a + n);
long long r = k + accumulate(a, a + n, 0ll);
while (l + 1 < r) {
long long m = l + (r - l) / 2;
if (check(m))
l = m;
else
r = m - 1;
}
if (check(r))
cout << r << "\n";
else
cout << l << "\n";
}
``` |
### Prompt
Generate a cpp solution to the following problem:
You are given n strings ti. Each string has cost ci.
Let's define the function of string <image>, where ps, i is the number of occurrences of s in ti, |s| is the length of the string s. Find the maximal value of function f(s) over all strings.
Note that the string s is not necessarily some string from t.
Input
The first line contains the only integer n (1 ≤ n ≤ 105) — the number of strings in t.
Each of the next n lines contains contains a non-empty string ti. ti contains only lowercase English letters.
It is guaranteed that the sum of lengths of all strings in t is not greater than 5·105.
The last line contains n integers ci ( - 107 ≤ ci ≤ 107) — the cost of the i-th string.
Output
Print the only integer a — the maximal value of the function f(s) over all strings s. Note one more time that the string s is not necessarily from t.
Examples
Input
2
aa
bb
2 1
Output
4
Input
2
aa
ab
2 1
Output
5
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, len;
char t[600013];
int id[600013];
int e[100013], c[100013];
pair<pair<int, int>, int> cur[600013];
int last[600013], where[600013];
int suffix[600013], lcp[600013];
void makeSA() {
for (int i = 0; i < len; i++) {
last[i] = t[i];
cur[i].second = where[i] = i;
}
for (int k = 1; k < len; k *= 2) {
for (int i = 0; i < len; i++) {
cur[i].first = make_pair(last[i], 0);
if (cur[i].second + k < len)
cur[i].first.second = last[where[cur[i].second + k]];
}
sort(cur, cur + len);
for (int i = 0; i < len; i++) where[cur[i].second] = i;
last[0] = 0;
for (int i = 1; i < len; i++)
last[i] = last[i - 1] + (cur[i].first != cur[i - 1].first);
}
for (int i = 0; i < len; i++) suffix[i] = cur[i].second;
int prev = 0;
for (int i = 0; i < len; i++) {
int& l = lcp[where[i]];
l = max(0, prev - 1);
while (t[i + l] == t[suffix[where[i] + 1] + l] && t[i + l] != '$') l += 1;
lcp[where[i]] = l;
prev = l;
}
lcp[len - 1] = 0;
}
long long sums[600013];
int l[600013], r[600013];
stack<int> has;
long long sum(int a, int b) { return sums[b] - (a ? sums[a - 1] : 0); }
void solve() {
sums[0] = c[id[suffix[0]]];
for (int i = 1; i < len; i++) sums[i] = sums[i - 1] + c[id[suffix[i]]];
fill(l, l + len, -1);
for (int i = 0; i < len - 1; i++) {
while (has.size() && lcp[has.top()] >= lcp[i]) has.pop();
if (has.size()) l[i] = has.top();
has.push(i);
}
while (has.size()) has.pop();
fill(r, r + len, len - 1);
for (int i = len - 2; i >= 0; i--) {
while (has.size() && lcp[has.top()] >= lcp[i]) has.pop();
if (has.size()) r[i] = has.top();
has.push(i);
}
long long ans = 0;
for (int i = 0; i < len; i++) {
if (t[suffix[i]] == '$') continue;
if (i < len - 1)
ans = max(ans, lcp[i] * (sums[r[i]] - (l[i] + 1 ? sums[l[i]] : 0)));
long long dist = e[id[suffix[i]]] - suffix[i];
if (i && dist == lcp[i - 1]) continue;
if (dist == lcp[i]) continue;
ans = max(ans, dist * c[id[suffix[i]]]);
}
printf("%lld\n", ans);
}
int main() {
scanf("%d", &n);
char* head = t;
for (int i = 0; i < n; i++) {
scanf(" %s", head);
while (*head) {
id[head - t] = i;
head++;
}
e[i] = head - t;
*head = '$';
id[head - t] = n;
head++;
}
len = head - t;
for (int i = 0; i < n; i++) scanf("%d", &c[i]);
makeSA();
solve();
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
The term of this problem is the same as the previous one, the only exception — increased restrictions.
Input
The first line contains two positive integers n and k (1 ≤ n ≤ 100 000, 1 ≤ k ≤ 109) — the number of ingredients and the number of grams of the magic powder.
The second line contains the sequence a1, a2, ..., an (1 ≤ ai ≤ 109), where the i-th number is equal to the number of grams of the i-th ingredient, needed to bake one cookie.
The third line contains the sequence b1, b2, ..., bn (1 ≤ bi ≤ 109), where the i-th number is equal to the number of grams of the i-th ingredient, which Apollinaria has.
Output
Print the maximum number of cookies, which Apollinaria will be able to bake using the ingredients that she has and the magic powder.
Examples
Input
1 1000000000
1
1000000000
Output
2000000000
Input
10 1
1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000
1 1 1 1 1 1 1 1 1 1
Output
0
Input
3 1
2 1 4
11 3 16
Output
4
Input
4 3
4 3 5 6
11 12 14 20
Output
3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long int a[100000 + 12], b[100000 + 12];
int n, k;
bool ok(long long int mid, int k) {
int i, j;
long long int need = 0;
for (i = 0; i < n; i++) {
need = mid * a[i];
if (need < b[i]) continue;
if (need - b[i] > k) return false;
k -= need - b[i];
}
return true;
}
int main() {
int i;
cin >> n >> k;
long long int low = 0, high = 1e10, mid;
for (i = 0; i < n; i++) cin >> a[i];
for (i = 0; i < n; i++) cin >> b[i];
while (low != high) {
mid = low + (high - low + 1) / 2;
if (ok(mid, k))
low = mid;
else
high = mid - 1;
}
cout << low << endl;
return 0;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
Consider an analog clock whose hour and minute hands are A and B centimeters long, respectively.
An endpoint of the hour hand and an endpoint of the minute hand are fixed at the same point, around which each hand rotates clockwise at constant angular velocity. It takes the hour and minute hands 12 hours and 1 hour to make one full rotation, respectively.
At 0 o'clock, the two hands overlap each other. H hours and M minutes later, what is the distance in centimeters between the unfixed endpoints of the hands?
Constraints
* All values in input are integers.
* 1 \leq A, B \leq 1000
* 0 \leq H \leq 11
* 0 \leq M \leq 59
Input
Input is given from Standard Input in the following format:
A B H M
Output
Print the answer without units. Your output will be accepted when its absolute or relative error from the correct value is at most 10^{-9}.
Examples
Input
3 4 9 0
Output
5.00000000000000000000
Input
3 4 10 40
Output
4.56425719433005567605
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
double a,b;
int h,m;
int main(){
scanf("%lf%lf%d%d",&a,&b,&h,&m);
printf("%.9f",sqrt(a*a+b*b-2*a*b*cos((abs(30*h-5.5*m)*(acos(-1)/180)))));
return 0;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
Write a program which reads a list of student test scores and evaluates the performance for each student.
The test scores for a student include scores of the midterm examination m (out of 50), the final examination f (out of 50) and the makeup examination r (out of 100). If the student does not take the examination, the score is indicated by -1.
The final performance of a student is evaluated by the following procedure:
* If the student does not take the midterm or final examination, the student's grade shall be F.
* If the total score of the midterm and final examination is greater than or equal to 80, the student's grade shall be A.
* If the total score of the midterm and final examination is greater than or equal to 65 and less than 80, the student's grade shall be B.
* If the total score of the midterm and final examination is greater than or equal to 50 and less than 65, the student's grade shall be C.
* If the total score of the midterm and final examination is greater than or equal to 30 and less than 50, the student's grade shall be D. However, if the score of the makeup examination is greater than or equal to 50, the grade shall be C.
* If the total score of the midterm and final examination is less than 30, the student's grade shall be F.
Input
The input consists of multiple datasets. For each dataset, three integers m, f and r are given in a line.
The input ends with three -1 for m, f and r respectively. Your program should not process for the terminal symbols.
The number of datasets (the number of students) does not exceed 50.
Output
For each dataset, print the grade (A, B, C, D or F) in a line.
Example
Input
40 42 -1
20 30 -1
0 2 -1
-1 -1 -1
Output
A
C
F
### Response
```cpp
#include<iostream>
int main(){
for (int m,f,r,s;std::cin>>m>>f>>r,s=m+f,m+1||f+1||r+1;std::cout<<((m+1&&f+1)?(s>=80?"A":(s>=65?"B":(s>=50?"C":(s>=30?(r>=50?"C":"D"):"F")))):"F")<<std::endl);
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
One day Om Nom found a thread with n beads of different colors. He decided to cut the first several beads from this thread to make a bead necklace and present it to his girlfriend Om Nelly.
<image>
Om Nom knows that his girlfriend loves beautiful patterns. That's why he wants the beads on the necklace to form a regular pattern. A sequence of beads S is regular if it can be represented as S = A + B + A + B + A + ... + A + B + A, where A and B are some bead sequences, " + " is the concatenation of sequences, there are exactly 2k + 1 summands in this sum, among which there are k + 1 "A" summands and k "B" summands that follow in alternating order. Om Nelly knows that her friend is an eager mathematician, so she doesn't mind if A or B is an empty sequence.
Help Om Nom determine in which ways he can cut off the first several beads from the found thread (at least one; probably, all) so that they form a regular pattern. When Om Nom cuts off the beads, he doesn't change their order.
Input
The first line contains two integers n, k (1 ≤ n, k ≤ 1 000 000) — the number of beads on the thread that Om Nom found and number k from the definition of the regular sequence above.
The second line contains the sequence of n lowercase Latin letters that represent the colors of the beads. Each color corresponds to a single letter.
Output
Print a string consisting of n zeroes and ones. Position i (1 ≤ i ≤ n) must contain either number one if the first i beads on the thread form a regular sequence, or a zero otherwise.
Examples
Input
7 2
bcabcab
Output
0000011
Input
21 2
ababaababaababaababaa
Output
000110000111111000011
Note
In the first sample test a regular sequence is both a sequence of the first 6 beads (we can take A = "", B = "bca"), and a sequence of the first 7 beads (we can take A = "b", B = "ca").
In the second sample test, for example, a sequence of the first 13 beads is regular, if we take A = "aba", B = "ba".
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int l, k, kmp[1000010], p = 0, cur, d, t, la, lb;
char s[1000010];
int main() {
scanf("%d%d", &l, &k);
scanf("%s", s + 1);
for (int i = 2; i <= l; i++) {
while (p && s[i] != s[p + 1]) p = kmp[p];
if (s[i] == s[p + 1]) p++;
kmp[i] = p;
}
for (int i = 1; i <= l; i++) {
cur = i - kmp[i], d = i / cur, t = d / k, la = i - k * t * cur,
lb = d / k * cur - la;
if (i % cur)
printf("%d", (lb > 0));
else
printf("%d", (lb >= 0));
}
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
Christmas was knocking on the door, and our protagonist, Bob, was preparing a spectacular present for his long-time second best friend Charlie. As chocolate boxes are lame, he decided to decorate a tree instead. Bob's tree can be represented as an undirected connected graph with n nodes (numbered 1 to n) and n-1 edges. Initially, Bob placed a decoration with label i on node i, for each 1 ≤ i ≤ n. However, as such a simple arrangement is lame, he decided to shuffle the decorations a bit. Formally, Bob did the following steps:
* First, he listed the n-1 edges in some order.
* Then, he considered the edges one by one in that order. For each edge (u, v), he swapped the decorations of node u with the one of node v.
After finishing, Bob seemed satisfied with the arrangement, so he went to sleep.
The next morning, Bob wakes up only to find out that his beautiful arrangement has been ruined! Last night, Bob's younger brother Bobo dropped some of the decorations on the floor while he was playing with the tree. Fortunately, no decorations were lost, so Bob can repair the tree in no time. However, he completely forgets how the tree looked like yesterday. Therefore, given the labels of the decorations still on the tree, Bob wants to know the number of possible configurations of the tree. As the result can be quite large, Bob will be happy if you can output the result modulo 1000000007 (10^9+7). Note that, it is possible that there exists no possible configurations.
Input
The first line contains a single integer n (2 ≤ n ≤ 500 000) — the number of nodes.
Each of the next n - 1 lines contains two integers u and v (1 ≤ u, v ≤ n), denoting that there is an edge connecting two nodes u and v. It is guaranteed that the given edges form a tree.
The last line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ n). For each i, a_i = 0 means that the decoration of node i has been dropped on the floor. Otherwise, a_i is the label of the decoration of node i. It is guaranteed that no label appears more than once.
Output
Output the number of possible configurations modulo 1000000007 (10^9+7).
Examples
Input
4
3 4
2 4
4 1
0 4 0 0
Output
2
Input
5
1 2
2 4
3 4
5 4
0 0 0 0 0
Output
12
Input
3
1 2
1 3
1 0 0
Output
0
Note
In the first example, the possible configurations of the tree are [2, 4, 1, 3] and [3, 4, 2, 1].
In the second example, note that while there are 4! = 24 possible permutations of the edges, each of them results in a possible configuration, there are only 12 different configurations.
In the third example, it is easy to see that the decoration 1 cannot stay at node 1 after the swaps.
### Response
```cpp
#include <bits/stdc++.h>
#pragma GCC optimize("O2,unroll-loops")
using namespace std;
const int inf = 1000000010;
const long long INF = 10000000000000010LL;
const int mod = 1000000007;
const int MAXN = 500010, LOG = 20;
int n, m, k, u, v, x, y, t, a, b;
int A[MAXN], deg[MAXN];
int par[MAXN], h[MAXN], parid[MAXN];
long long F[MAXN], ans = 1;
int f[MAXN][2], nex2[MAXN], bad[MAXN];
bool mark[MAXN];
vector<pair<int, int> > G[MAXN];
map<pair<int, int>, int> mp;
map<int, int> nex[MAXN];
set<pair<int, int> > st;
void dfs(int node) {
h[node] = h[par[node]] + 1;
for (pair<int, int> p : G[node])
if (p.first != par[node]) {
par[p.first] = node;
parid[p.first] = p.second;
dfs(p.first);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
F[0] = 1;
for (int i = 1; i < MAXN; i++) F[i] = F[i - 1] * i % mod;
cin >> n;
for (int i = 1; i < n; i++) {
cin >> u >> v;
mp[{u, v}] = mp[{v, u}] = i;
G[u].push_back({v, i});
G[v].push_back({u, i});
}
dfs(1);
for (int i = 1; i <= n; i++) {
cin >> A[i];
if (!A[i]) continue;
int v = i, u = A[i];
if (u == v) return cout << 0 << '\n', 0;
vector<int> v1, v2;
while (u != v) {
if (h[u] < h[v]) {
v1.push_back(v);
v = par[v];
} else {
v2.push_back(u);
u = par[u];
}
}
v1.push_back(u);
reverse(v2.begin(), v2.end());
for (int x : v2) v1.push_back(x);
for (int i = 1; i < v1.size(); i++) {
pair<int, int> p = {v1[i - 1], v1[i]};
if (st.count(p)) return cout << 0 << '\n', 0;
st.insert(p);
int id = mp[{v1[i - 1], v1[i]}];
if (i == 1) f[v1[i - 1]][0] = id;
if (i == v1.size() - 1) f[v1[i]][1] = id;
if (1 < i && i < v1.size() - 1) {
if (f[v1[i]][1] == id) return cout << 0 << '\n', 0;
if (f[v1[i - 1]][0] == id) return cout << 0 << '\n', 0;
}
}
for (int i = 1; i + 1 < v1.size(); i++) {
int x = mp[{v1[i - 1], v1[i]}];
int y = mp[{v1[i + 1], v1[i]}];
if (nex[v1[i]][x]) return cout << 0 << '\n', 0;
nex[v1[i]][x] = y;
}
}
for (int i = 1; i <= n; i++) {
int ted = G[i].size() - (f[i][0] > 0) - (f[i][1] > 0) - nex[i].size();
for (pair<int, int> p : nex[i]) nex2[p.first] = p.second, bad[p.second] = 1;
if (f[i][0] && f[i][1]) {
int v = f[i][0], l = 0;
while (nex2[v]) v = nex2[v], l++;
if (v == f[i][1] && l < G[i].size() - 1) return cout << 0 << '\n', 0;
}
for (pair<int, int> p : G[i]) {
int v = p.second;
if (bad[v]) continue;
while (1) {
if (mark[v]) return cout << 0 << '\n', 0;
mark[v] = 1;
if (!nex2[v]) break;
v = nex2[v];
}
}
for (pair<int, int> p : G[i])
if (!mark[p.second]) return cout << 0 << '\n', 0;
ans = ans * F[max(ted, 0)] % mod;
for (pair<int, int> p : G[i])
nex2[p.second] = mark[p.second] = bad[p.second] = 0;
}
cout << ans << "\n";
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
A connected undirected graph is called a vertex cactus, if each vertex of this graph belongs to at most one simple cycle.
A simple cycle in a undirected graph is a sequence of distinct vertices v1, v2, ..., vt (t > 2), such that for any i (1 ≤ i < t) exists an edge between vertices vi and vi + 1, and also exists an edge between vertices v1 and vt.
A simple path in a undirected graph is a sequence of not necessarily distinct vertices v1, v2, ..., vt (t > 0), such that for any i (1 ≤ i < t) exists an edge between vertices vi and vi + 1 and furthermore each edge occurs no more than once. We'll say that a simple path v1, v2, ..., vt starts at vertex v1 and ends at vertex vt.
You've got a graph consisting of n vertices and m edges, that is a vertex cactus. Also, you've got a list of k pairs of interesting vertices xi, yi, for which you want to know the following information — the number of distinct simple paths that start at vertex xi and end at vertex yi. We will consider two simple paths distinct if the sets of edges of the paths are distinct.
For each pair of interesting vertices count the number of distinct simple paths between them. As this number can be rather large, you should calculate it modulo 1000000007 (109 + 7).
Input
The first line contains two space-separated integers n, m (2 ≤ n ≤ 105; 1 ≤ m ≤ 105) — the number of vertices and edges in the graph, correspondingly. Next m lines contain the description of the edges: the i-th line contains two space-separated integers ai, bi (1 ≤ ai, bi ≤ n) — the indexes of the vertices connected by the i-th edge.
The next line contains a single integer k (1 ≤ k ≤ 105) — the number of pairs of interesting vertices. Next k lines contain the list of pairs of interesting vertices: the i-th line contains two space-separated numbers xi, yi (1 ≤ xi, yi ≤ n; xi ≠ yi) — the indexes of interesting vertices in the i-th pair.
It is guaranteed that the given graph is a vertex cactus. It is guaranteed that the graph contains no loops or multiple edges. Consider the graph vertices are numbered from 1 to n.
Output
Print k lines: in the i-th line print a single integer — the number of distinct simple ways, starting at xi and ending at yi, modulo 1000000007 (109 + 7).
Examples
Input
10 11
1 2
2 3
3 4
1 4
3 5
5 6
8 6
8 7
7 6
7 9
9 10
6
1 2
3 5
6 9
9 2
9 3
9 10
Output
2
2
2
4
4
1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = 0;
c = getchar();
}
while (c >= '0' && c <= '9')
x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
return f ? x : -x;
}
const long long N = 1e5 + 5, M = 2e5 + 5, mod = 1e9 + 7;
long long tot = 1, ver[M], nxt[M], head[N];
void add(long long u, long long v) {
ver[++tot] = v;
nxt[tot] = head[u];
head[u] = tot;
}
long long tot2, ver2[M], nxt2[M], head2[N];
void Add(long long u, long long v) {
ver2[++tot2] = v;
nxt2[tot2] = head2[u];
head2[u] = tot2;
}
long long dfn[N], low[N], num, bridge[M];
void tarjan(long long u, long long lst) {
dfn[u] = low[u] = ++num;
for (long long i = head[u]; i; i = nxt[i]) {
long long v = ver[i];
if (!dfn[v]) {
tarjan(v, i);
low[u] = min(low[u], low[v]);
if (low[v] > dfn[u]) bridge[i] = bridge[i ^ 1] = 1;
} else if (i != (lst ^ 1))
low[u] = min(low[u], dfn[v]);
}
}
long long col[N], cnt[N], dcc;
void dfs1(long long u) {
col[u] = dcc;
cnt[dcc]++;
for (long long i = head[u]; i; i = nxt[i]) {
long long v = ver[i];
if (bridge[i] || col[v]) continue;
dfs1(v);
}
}
long long dis[N];
void dfs2(long long u, long long fa) {
dis[u] += (cnt[u] > 1);
for (long long i = head2[u]; i; i = nxt2[i]) {
long long v = ver2[i];
if (v == fa) continue;
dis[v] = dis[u];
dfs2(v, u);
}
}
long long dep[N], f[N][30], t = 20;
queue<long long> q;
void bfs(long long st) {
q.push(st);
dep[st] = 1;
while (!q.empty()) {
long long u = q.front();
q.pop();
for (long long i = head2[u]; i; i = nxt2[i]) {
long long v = ver2[i];
if (dep[v]) continue;
dep[v] = dep[u] + 1;
f[v][0] = u;
for (long long j = 1; j <= t; j++) f[v][j] = f[f[v][j - 1]][j - 1];
q.push(v);
}
}
}
long long lca(long long u, long long v) {
if (dep[u] > dep[v]) swap(u, v);
for (long long i = t; i >= 0; i--)
if (dep[f[v][i]] >= dep[u]) v = f[v][i];
if (u == v) return u;
for (long long i = t; i >= 0; i--)
if (f[u][i] != f[v][i]) {
u = f[u][i];
v = f[v][i];
}
return f[u][0];
}
long long qpow(long long a, long long x) {
long long res = 1;
while (x) {
if (x & 1) res = (res * a) % mod;
a = (a * a) % mod;
x >>= 1;
}
return res;
}
long long n, m, T;
signed main() {
n = read(), m = read();
for (long long i = 1; i <= m; i++) {
long long u = read(), v = read();
add(u, v);
add(v, u);
}
tarjan(1, -1);
for (long long i = 1; i <= n; i++) {
if (!col[i]) {
dcc++;
dfs1(i);
}
}
for (long long i = 1; i <= n; i++) {
for (long long j = head[i]; j; j = nxt[j]) {
long long v = ver[j];
if (col[i] != col[v]) Add(col[i], col[v]);
}
}
dfs2(1, -1);
bfs(1);
T = read();
while (T--) {
long long u = col[read()], v = col[read()];
long long l = lca(u, v);
printf("%lld\n", qpow(2, dis[u] + dis[v] - dis[l] * 2 + (cnt[l] > 1)));
}
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
You came to a local shop and want to buy some chocolate bars. There are n bars in the shop, i-th of them costs a_i coins (and you want to buy all of them).
You have m different coupons that allow you to buy chocolate bars. i-th coupon allows you to buy q_i chocolate bars while you have to pay only for the q_i - 1 most expensive ones (so, the cheapest bar of those q_i bars is for free).
You can use only one coupon; if you use coupon i, you have to choose q_i bars and buy them using the coupon, and buy all the remaining n - q_i bars without any discounts.
To decide which coupon to choose, you want to know what will be the minimum total amount of money you have to pay if you use one of the coupons optimally.
Input
The first line contains one integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the number of chocolate bars in the shop.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the cost of i-th chocolate bar.
The third line contains one integer m (1 ≤ m ≤ n - 1) — the number of coupons you have.
The fourth line contains m integers q_1, q_2, ..., q_m (2 ≤ q_i ≤ n), where q_i is the number of chocolate bars you have to buy using i-th coupon so that the least expensive of them will be for free. All values of q_i are pairwise distinct.
Output
Print m integers, i-th of them should be the minimum amount of money you have to pay if you buy q_i bars with i-th coupon, and all the remaining bars one by one for their full price.
Example
Input
7
7 1 3 1 4 10 8
2
3 4
Output
27
30
Note
Consider the first example.
If we use the first coupon, we may choose chocolate bars having indices 1, 6 and 7, and we pay 18 coins for them and 9 coins for all other bars.
If we use the second coupon, we may choose chocolate bars having indices 1, 5, 6 and 7, and we pay 25 coins for them and 5 coins for all other bars.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout.precision(20);
long long int n, s = 0;
cin >> n;
long long int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
s += a[i];
}
sort(a, a + n, greater<long long int>());
long long int m, q, s1;
cin >> m;
for (int i = 0; i < m; i++) {
s1 = s;
cin >> q;
s1 -= a[q - 1];
cout << s1 << endl;
}
return 0;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
You are given an array a of n integers.
You need to find the maximum value of a_{i} | ( a_{j} \& a_{k} ) over all triplets (i,j,k) such that i < j < k.
Here \& denotes the [bitwise AND operation](https://en.wikipedia.org/wiki/Bitwise_operation#AND), and | denotes the [bitwise OR operation](https://en.wikipedia.org/wiki/Bitwise_operation#OR).
Input
The first line of input contains the integer n (3 ≤ n ≤ 10^{6}), the size of the array a.
Next line contains n space separated integers a_1, a_2, ..., a_n (0 ≤ a_{i} ≤ 2 ⋅ 10^{6}), representing the elements of the array a.
Output
Output a single integer, the maximum value of the expression given in the statement.
Examples
Input
3
2 4 6
Output
6
Input
4
2 8 4 7
Output
12
Note
In the first example, the only possible triplet is (1, 2, 3). Hence, the answer is 2 | (4 \& 6) = 6.
In the second example, there are 4 possible triplets:
1. (1, 2, 3), value of which is 2|(8\&4) = 2.
2. (1, 2, 4), value of which is 2|(8\&7) = 2.
3. (1, 3, 4), value of which is 2|(4\&7) = 6.
4. (2, 3, 4), value of which is 8|(4\&7) = 12.
The maximum value hence is 12.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int read() {
int res = 0;
char ch = ' ';
while (ch > '9' || ch < '0') ch = getchar();
while (ch >= '0' && ch <= '9') res *= 10, res += ch - '0', ch = getchar();
return res;
}
int cnt[2097156];
void insert(int x, int y) {
if (cnt[x | y] >= 2) return;
if (x == 0) {
++cnt[y];
return;
}
insert(x & x - 1, y | (x & -x)), insert(x & x - 1, y);
}
int n, ans = 0;
int A[2097156];
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) A[i] = read();
for (int i = n, cur; i >= 1; --i) {
if (i <= n - 2) {
cur = 0;
for (int j = 21; j >= 0; --j)
if ((~A[i] >> j & 1) && cnt[cur | (1 << j)] == 2) cur |= (1 << j);
ans = max(ans, A[i] | cur);
}
insert(A[i], 0);
}
cout << ans << endl;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains ai worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a1, worms in second pile are labeled with numbers a1 + 1 to a1 + a2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
Input
The first line contains a single integer n (1 ≤ n ≤ 105), the number of piles.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 103, a1 + a2 + ... + an ≤ 106), where ai is the number of worms in the i-th pile.
The third line contains single integer m (1 ≤ m ≤ 105), the number of juicy worms said by Marmot.
The fourth line contains m integers q1, q2, ..., qm (1 ≤ qi ≤ a1 + a2 + ... + an), the labels of the juicy worms.
Output
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number qi is.
Examples
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
Note
For the sample input:
* The worms with labels from [1, 2] are in the first pile.
* The worms with labels from [3, 9] are in the second pile.
* The worms with labels from [10, 12] are in the third pile.
* The worms with labels from [13, 16] are in the fourth pile.
* The worms with labels from [17, 25] are in the fifth pile.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long ara[100010];
vector<long long> v;
vector<long long> v1;
long long val, sum, val1;
long long f, l, mid, mid1, res1, res2, s;
long long n, m;
void bs(long long s) {
f = 0;
l = n - 1;
while (f <= l) {
mid = (f + l) / 2;
mid1 = mid - 1;
res1 = ara[mid];
res2 = ara[mid1];
if (s < res1 && mid1 < 0) {
cout << "1";
break;
} else if (s < res1 && s < res2)
l = mid - 1;
else if (s > res1 && s > res2)
f = mid + 1;
else if ((s >= res1 && s >= res2) || (s < res1 && s > res2)) {
cout << mid + 1;
break;
} else {
l = mid - 1;
}
}
}
int main() {
sum = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> val;
sum += val;
ara[i] = sum;
}
cin >> m;
for (int i = 0; i < m; i++) {
cin >> val1;
v1.push_back(val1);
}
for (int i = 0; i < m; i++) {
s = v1.at(i);
bs(s);
cout << endl;
}
}
``` |
### Prompt
Generate a cpp solution to the following problem:
You are running through a rectangular field. This field can be represented as a matrix with 3 rows and m columns. (i, j) denotes a cell belonging to i-th row and j-th column.
You start in (2, 1) and have to end your path in (2, m). From the cell (i, j) you may advance to:
* (i - 1, j + 1) — only if i > 1,
* (i, j + 1), or
* (i + 1, j + 1) — only if i < 3.
However, there are n obstacles blocking your path. k-th obstacle is denoted by three integers ak, lk and rk, and it forbids entering any cell (ak, j) such that lk ≤ j ≤ rk.
You have to calculate the number of different paths from (2, 1) to (2, m), and print it modulo 109 + 7.
Input
The first line contains two integers n and m (1 ≤ n ≤ 104, 3 ≤ m ≤ 1018) — the number of obstacles and the number of columns in the matrix, respectively.
Then n lines follow, each containing three integers ak, lk and rk (1 ≤ ak ≤ 3, 2 ≤ lk ≤ rk ≤ m - 1) denoting an obstacle blocking every cell (ak, j) such that lk ≤ j ≤ rk. Some cells may be blocked by multiple obstacles.
Output
Print the number of different paths from (2, 1) to (2, m), taken modulo 109 + 7. If it is impossible to get from (2, 1) to (2, m), then the number of paths is 0.
Example
Input
2 5
1 3 4
2 2 3
Output
2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
long long s[3];
long long n, m;
struct Data {
long long a, l, r;
Data() {}
Data(long long a, long long l, long long r) : a(a), l(l), r(r) {}
} p[10000 + 10];
bool cmp(const Data& data1, const Data& data2) { return data1.l < data2.l; }
vector<vector<long long> > mul(vector<vector<long long> > A,
vector<vector<long long> > B) {
vector<vector<long long> > C(3, vector<long long>(3));
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 3; k++) {
C[i][j] = (C[i][j] + A[i][k] * B[k][j]) % MOD;
}
}
}
return C;
}
vector<vector<long long> > pow(vector<vector<long long> > A, long long n) {
vector<vector<long long> > B(3, vector<long long>(3));
for (int i = 0; i < 3; i++) B[i][i] = 1;
while (n > 0) {
if (n & 1) B = mul(B, A);
A = mul(A, A);
n >>= 1;
}
return B;
}
inline bool empty() { return (s[0] == -1 && s[1] == -1 && s[2] == -1); }
inline pair<long long, long long> getmin() {
pair<long long, long long> p = make_pair(-1, -1);
for (int i = 0; i < 3; i++) {
if (s[i] > 0 && (p.first == -1 || s[i] < p.first))
p = make_pair(s[i], i + 3);
}
return p;
}
long long solve() {
sort(p, p + n, cmp);
s[0] = s[1] = s[2] = -1;
vector<pair<long long, long long> > v;
vector<vector<long long> > A(3, vector<long long>(3, 1)),
res(3, vector<long long>(3, 0));
A[0][2] = A[2][0] = 0;
res[0][0] = res[1][1] = res[2][2] = 1;
for (int i = 0; i < n || !empty(); i++) {
while (!empty()) {
pair<long long, long long> pr = getmin();
if (i >= n || pr.first < p[i].l) {
v.push_back(pr);
s[pr.second - 3] = -1;
} else {
break;
}
}
if (i < n) {
if (s[p[i].a] == -1) v.push_back(make_pair(p[i].l, p[i].a));
s[p[i].a] = max(s[p[i].a], p[i].r);
}
}
long long k = 1;
for (int i = 0; i <= v.size(); i++) {
long long nxt = i < v.size() ? v[i].first : m;
res = mul(pow(A, nxt - k), res);
k = nxt;
if (i < v.size()) {
if (v[i].second >= 3) {
v[i].second -= 3;
for (int j = 0; j < 3; j++) A[v[i].second][j] = 1;
if (v[i].second % 2 == 0) A[v[i].second][2 - v[i].second] = 0;
} else {
for (int j = 0; j < 3; j++) A[v[i].second][j] = 0;
}
}
}
return res[1][1];
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> p[i].a >> p[i].l >> p[i].r;
p[i].a--;
p[i].l--;
}
cout << solve() << endl;
return 0;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
Indian summer is such a beautiful time of the year! A girl named Alyona is walking in the forest and picking a bouquet from fallen leaves. Alyona is very choosy — she doesn't take a leaf if it matches the color and the species of the tree of one of the leaves she already has. Find out how many leaves Alyona has picked.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the number of leaves Alyona has found. The next n lines contain the leaves' descriptions. Each leaf is characterized by the species of the tree it has fallen from and by the color. The species of the trees and colors are given in names, consisting of no more than 10 lowercase Latin letters. A name can not be an empty string. The species of a tree and the color are given in each line separated by a space.
Output
Output the single number — the number of Alyona's leaves.
Examples
Input
5
birch yellow
maple red
birch yellow
maple yellow
maple green
Output
4
Input
3
oak yellow
oak yellow
oak yellow
Output
1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int INF = ~(1 << 31);
int gcd(int a, int b) {
if (b > a) {
b += a;
a = b - a;
b = b - a;
}
if (b == 0)
return a;
else
return gcd(b, a % b);
}
int main() {
int m;
cin >> m;
string s1, s2;
set<pair<string, string> > a;
for (int i = 0; i < m; i++) {
cin >> s1 >> s2;
a.insert(make_pair(s1, s2));
}
cout << a.size() << endl;
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
Barney lives in country USC (United States of Charzeh). USC has n cities numbered from 1 through n and n - 1 roads between them. Cities and roads of USC form a rooted tree (Barney's not sure why it is rooted). Root of the tree is the city number 1. Thus if one will start his journey from city 1, he can visit any city he wants by following roads.
<image>
Some girl has stolen Barney's heart, and Barney wants to find her. He starts looking for in the root of the tree and (since he is Barney Stinson not a random guy), he uses a random DFS to search in the cities. A pseudo code of this algorithm is as follows:
let starting_time be an array of length n
current_time = 0
dfs(v):
current_time = current_time + 1
starting_time[v] = current_time
shuffle children[v] randomly (each permutation with equal possibility)
// children[v] is vector of children cities of city v
for u in children[v]:
dfs(u)
As told before, Barney will start his journey in the root of the tree (equivalent to call dfs(1)).
Now Barney needs to pack a backpack and so he wants to know more about his upcoming journey: for every city i, Barney wants to know the expected value of starting_time[i]. He's a friend of Jon Snow and knows nothing, that's why he asked for your help.
Input
The first line of input contains a single integer n (1 ≤ n ≤ 105) — the number of cities in USC.
The second line contains n - 1 integers p2, p3, ..., pn (1 ≤ pi < i), where pi is the number of the parent city of city number i in the tree, meaning there is a road between cities numbered pi and i in USC.
Output
In the first and only line of output print n numbers, where i-th number is the expected value of starting_time[i].
Your answer for each city will be considered correct if its absolute or relative error does not exceed 10 - 6.
Examples
Input
7
1 2 1 1 4 4
Output
1.0 4.0 5.0 3.5 4.5 5.0 5.0
Input
12
1 1 2 2 4 4 3 3 1 10 8
Output
1.0 5.0 5.5 6.5 7.5 8.0 8.0 7.0 7.5 6.5 7.5 8.0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <class T>
void read(T &x) {
T ans = 0;
short f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
ans = (ans << 1) + (ans << 3) + (ch ^ 48);
ch = getchar();
}
x = ans * f;
}
int n;
int siz[100010];
double f[100010];
int x;
int head[100010], Next[100010 << 1], ver[100010 << 1], tot;
void add(int x, int y) {
ver[++tot] = y;
Next[tot] = head[x];
head[x] = tot;
}
void dfs(int x, int fa) {
siz[x] = 1;
for (int i = head[x]; i; i = Next[i]) {
int y = ver[i];
if (y == fa) continue;
dfs(y, x);
siz[x] += siz[y];
}
}
void DFS(int x, int fa) {
for (int i = head[x]; i; i = Next[i]) {
int y = ver[i];
if (y == fa) continue;
f[y] = f[x] + 1 + (siz[x] - siz[y] - 1) / 2.0;
DFS(y, x);
}
}
signed main() {
read(n);
for (int i = 2; i <= n; i++) read(x), add(i, x), add(x, i);
dfs(1, -1);
f[1] = 1;
DFS(1, -1);
for (int i = 1; i <= n; i++) printf("%.1lf ", f[i]);
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Japanese video game company has developed the music video game called Step Step Evolution. The gameplay of Step Step Evolution is very simple. Players stand on the dance platform, and step on panels on it according to a sequence of arrows shown in the front screen.
There are eight types of direction arrows in the Step Step Evolution: UP, UPPER RIGHT, RIGHT, LOWER RIGHT, DOWN, LOWER LEFT, LEFT, and UPPER LEFT. These direction arrows will scroll upward from the bottom of the screen. When the direction arrow overlaps the stationary arrow nearby the top, then the player must step on the corresponding arrow panel on the dance platform. The figure below shows how the dance platform looks like.
<image>
Figure 1: the dance platform for Step Step Evolution
In the game, you have to obey the following rule:
* Except for the beginning of the play, you must not press the arrow panel which is not correspond to the edit data.
* The foot must stay upon the panel where it presses last time, and will not be moved until it’s going to press the next arrow panel.
* The left foot must not step on the panel which locates at right to the panel on which the right foot rests. Conversely, the right foot must not step on the panel which locates at left to the panel on which the left foot rests.
As for the third condition, the following figure shows the examples of the valid and invalid footsteps.
<image>
Figure 2: the examples of valid and invalid footsteps
The first one (left foot for LEFT, right foot for DOWN) and the second one (left foot for LOWER LEFT, right foot for UPPER LEFT) are valid footstep. The last one (left foot for RIGHT, right foot for DOWN) is invalid footstep.
Note that, at the beginning of the play, the left foot and right foot can be placed anywhere at the arrow panel. Also, you can start first step with left foot or right foot, whichever you want.
To play this game in a beautiful way, the play style called “ Natural footstep style” is commonly known among talented players. “Natural footstep style” is the style in which players make steps by the left foot and the right foot in turn. However, when a sequence of arrows is difficult, players are sometimes forced to violate this style.
Now, your friend has created an edit data (the original sequence of direction arrows to be pushed) for you. You are interested in how many times you have to violate “Natural footstep style” when you optimally played with this edit data. In other words, what is the minimum number of times you have to step on two consecutive arrows using the same foot?
Input
The input consists of several detasets. Each dataset is specified by one line containing a sequence of direction arrows. Directions are described by numbers from 1 to 9, except for 5. The figure below shows the correspondence between numbers and directions.
You may assume that the length of the sequence is between 1 and 100000, inclusive. Also, arrows of the same direction won’t appear consecutively in the line. The end of the input is indicated by a single “#”.
<image>
Figure 3: the correspondence of the numbers to the direction arrows
Output
For each dataset, output how many times you have to violate “Natural footstep style” when you play optimally in one line.
Examples
Input
1
12
123
369
6748
4247219123
1232123212321232
#
Output
0
0
1
0
1
2
7
Input
1
12
123
369
6748
4247219123
1232123212321232
Output
0
0
1
0
1
2
7
### Response
```cpp
///
// File: 2254.cpp
// Author: ymiyamoto
//
// Created on Fri Dec 29 11:08:05 2017
//
#include <cstdint>
#include <iostream>
#include <string>
using namespace std;
enum turn_t {
Left,
Right,
};
uint32_t violates(string arrows, turn_t start)
{
uint32_t left;
uint32_t right;
if (start == Left) {
right = (arrows[0] - '0' + 2) % 3;
} else {
left = (arrows[0] - '0' + 2) % 3;
}
turn_t turn = start;
uint32_t count = 0;
for (uint32_t i = 1; i < arrows.size(); i++) {
uint32_t arrow = (arrows[i] - '0' + 2) % 3;
if (turn == Left) {
if (arrow <= right) {
left = arrow;
turn = Right;
} else {
right = arrow;
turn = Left;
count++;
}
} else {
if (left <= arrow) {
right = arrow;
turn = Left;
} else {
left = arrow;
turn = Right;
count++;
}
}
}
return count;
}
int32_t main()
{
while (true) {
string arrows;
cin >> arrows;
if (arrows[0] == '#') break;
if (arrows.size() <= 2) {
cout << 0 << endl;
continue;
}
cout << min(violates(arrows, Left), violates(arrows, Right)) << endl;
}
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
In Japan, temperature is usually expressed using the Celsius (℃) scale. In America, they used the Fahrenheit (℉) scale instead. $20$ degrees Celsius is roughly equal to $68$ degrees Fahrenheit. A phrase such as "Today’s temperature is $68$ degrees" is commonly encountered while you are in America.
A value in Fahrenheit can be converted to Celsius by first subtracting $32$ and then multiplying by $\frac{5}{9}$. A simplified method may be used to produce a rough estimate: first subtract $30$ and then divide by $2$. Using the latter method, $68$ Fahrenheit is converted to $19$ Centigrade, i.e., $\frac{(68-30)}{2}$.
Make a program to convert Fahrenheit to Celsius using the simplified method: $C = \frac{F - 30}{2}$.
Input
The input is given in the following format.
$F$
The input line provides a temperature in Fahrenheit $F$ ($30 \leq F \leq 100$), which is an integer divisible by $2$.
Output
Output the converted Celsius temperature in a line.
Examples
Input
68
Output
19
Input
50
Output
10
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(){
int a;
cin >> a;
cout << (a-30)/2 << endl;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
Let \mathrm{popcount}(n) be the number of `1`s in the binary representation of n. For example, \mathrm{popcount}(3) = 2, \mathrm{popcount}(7) = 3, and \mathrm{popcount}(0) = 0.
Let f(n) be the number of times the following operation will be done when we repeat it until n becomes 0: "replace n with the remainder when n is divided by \mathrm{popcount}(n)." (It can be proved that, under the constraints of this problem, n always becomes 0 after a finite number of operations.)
For example, when n=7, it becomes 0 after two operations, as follows:
* \mathrm{popcount}(7)=3, so we divide 7 by 3 and replace it with the remainder, 1.
* \mathrm{popcount}(1)=1, so we divide 1 by 1 and replace it with the remainder, 0.
You are given an integer X with N digits in binary. For each integer i such that 1 \leq i \leq N, let X_i be what X becomes when the i-th bit from the top is inverted. Find f(X_1), f(X_2), \ldots, f(X_N).
Constraints
* 1 \leq N \leq 2 \times 10^5
* X is an integer with N digits in binary, possibly with leading zeros.
Input
Input is given from Standard Input in the following format:
N
X
Output
Print N lines. The i-th line should contain the value f(X_i).
Examples
Input
3
011
Output
2
1
1
Input
23
00110111001011011001110
Output
2
1
2
2
1
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
1
3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=1e6+100;
ll qpow(ll x,ll n,int mod)
{
ll sum=1;
while(n){
if(n&1) sum=sum*x%mod;
x=x*x%mod;
n>>=1;
}
return sum;
}
int ans(int x)
{
if(x==0) return 0;
int kk=__builtin_popcount(x);
return 1+ans(x%kk);
}
int main()
{
ios::sync_with_stdio(0);cin.tie(0);
int n;cin>>n;
string s;cin>>s;
int one=0;
for(int i=0;i<n;i++){
if(s[i]=='1') one++;
}
int p1=0,p2=0;
for(int i=0;i<n;i++){
if(one!=1){
p1=(p1*2+s[i]-'0')%(one-1);
}
p2=(p2*2+s[i]-'0')%(one+1);
}
for(int i=0;i<n;i++){
if((s[i]=='1'&&one==1)){
cout<<0<<endl;
}
else if(s[i]=='1'){
cout<<1+ans((p1-qpow(2,n-i-1,one-1)+(one-1))%(one-1))<<endl;
}
else if(s[i]=='0'){
cout<<1+ans((p2+qpow(2,n-i-1,one+1)+(one+1))%(one+1))<<endl;
}
}
return 0;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
There are a total of W x H squares, with H rows vertically and W columns horizontally. Some squares are marked. Create a program that reads the marked state of each square and outputs the maximum rectangular area consisting of only the unmarked squares.
The input data consists of one line of W characters, given H lines. For example, the following data is given.
.. *.... **.
..........
** .... ***.
.... * .....
.. * .......
... ** .....
. *. * ......
..........
.. **......
. * .. * .....
One line of input data represents the square of one line. Of the character strings in the input data,. (Period) indicates unmarked squares, and * (asterisk) indicates marked squares. The input data string does not contain any characters other than periods, asterisks, and line breaks.
In the above example, the rectangle indicated by 0 in the figure below is the largest.
.. *.... **.
..........
** .... ***.
.... * 00000
.. * ..00000
... ** 00000
. *. *. 00000
..... 00000
.. **. 00000
. * .. * 00000
Therefore, if you output 35, the answer will be correct. If all the squares are marked, output 0.
Input
Given multiple datasets. Each dataset starts with a line of H and W separated by spaces, followed by an H x W rectangle. Both H and W shall be 500 or less.
The input ends with a line containing two 0s. The number of datasets does not exceed 20.
Output
For each dataset, output the area of the largest rectangle on one line.
Example
Input
10 10
...*....**
..........
**....**..
........*.
..*.......
**........
.*........
..........
....*..***
.*....*...
10 10
..*....*..
.*.*...*..
*****..*..
*...*..*..
*...*..*..
..........
****.*...*
..*..*...*
.*...*...*
****..***.
2 3
...
...
0 0
Output
28
12
6
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
#define int long long
int getS(vector<int>&H){
int N=H.size();
vector<int>L(N),R(N);
stack<int>S;
for(int i=0;i<N;i++){
while(!S.empty()&&H[i]<=H[S.top()])S.pop();
L[i]=S.empty()?0:(S.top()+1);
S.push(i);
}
S=stack<int>();
for(int i=N-1;i>=0;i--){
while(!S.empty()&&H[i]<=H[S.top()])S.pop();
R[i]=S.empty()?N:S.top();
S.push(i);
}
int ma=0;
for(int i=0;i<N;i++)ma=max(ma,(R[i]-L[i])*H[i]);
return ma;
}
int H,W;
vector<int>V[500];
void solve(){
fill_n(V,H,vector<int>(W,0));
int ma=0;
for(int i=0;i<H;i++){
char fld[510];
cin>>fld;
for(int j=0;j<W;j++){
if(fld[j]=='*')continue;
V[i][j]=(i?V[i-1][j]:0)+1;
}
ma=max(ma,getS(V[i]));
}
cout<<ma<<endl;
}
signed main(){
while(cin>>H>>W,H||W)solve();
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
Fox Ciel wants to write a task for a programming contest. The task is: "You are given a simple undirected graph with n vertexes. Each its edge has unit length. You should calculate the number of shortest paths between vertex 1 and vertex 2."
Same with some writers, she wants to make an example with some certain output: for example, her birthday or the number of her boyfriend. Can you help her to make a test case with answer equal exactly to k?
Input
The first line contains a single integer k (1 ≤ k ≤ 109).
Output
You should output a graph G with n vertexes (2 ≤ n ≤ 1000). There must be exactly k shortest paths between vertex 1 and vertex 2 of the graph.
The first line must contain an integer n. Then adjacency matrix G with n rows and n columns must follow. Each element of the matrix must be 'N' or 'Y'. If Gij is 'Y', then graph G has a edge connecting vertex i and vertex j. Consider the graph vertexes are numbered from 1 to n.
The graph must be undirected and simple: Gii = 'N' and Gij = Gji must hold. And there must be at least one path between vertex 1 and vertex 2. It's guaranteed that the answer exists. If there multiple correct answers, you can output any of them.
Examples
Input
2
Output
4
NNYY
NNYY
YYNN
YYNN
Input
9
Output
8
NNYYYNNN
NNNNNYYY
YNNNNYYY
YNNNNYYY
YNNNNYYY
NYYYYNNN
NYYYYNNN
NYYYYNNN
Input
1
Output
2
NY
YN
Note
In first example, there are 2 shortest paths: 1-3-2 and 1-4-2.
In second example, there are 9 shortest paths: 1-3-6-2, 1-3-7-2, 1-3-8-2, 1-4-6-2, 1-4-7-2, 1-4-8-2, 1-5-6-2, 1-5-7-2, 1-5-8-2.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
bool check(long long n, long long pos) { return n & (1LL << pos); }
long long Set(long long n, long long pos) { return n = n | (1LL << pos); }
char grid[1003][1003];
void conn(long long i, long long j) {
grid[i][j] = 'Y';
grid[j][i] = 'Y';
}
long long point[100];
int main() {
long long i, j, k, l, m, n, o, r, q;
long long testcase;
long long input, flag, tag, ans;
while (cin >> k) {
for (i = 1; i <= 1000; i++)
for (j = 1; j <= 1000; j++) grid[i][j] = 'N';
long long mxbit = 0;
for (i = 0; i <= 30; i++) point[i] = 0;
conn(1, 3);
long long node = 2;
for (i = 30; i >= 0; i--) {
if (check(k, i) == 0) continue;
mxbit = max(mxbit, i);
node++;
if (i == mxbit) {
for (j = 0; j < i; j++) {
conn(node, node + 1);
conn(node, node + 2);
conn(node + 2, node + 3);
conn(node + 1, node + 3);
point[j] = node + 1;
node += 3;
}
conn(node, 2);
} else {
conn(node, point[i]);
for (j = i + 1; j < mxbit; j++) {
conn(node, node + 1);
conn(node + 1, node + 2);
node += 2;
}
conn(node, 2);
}
}
assert(1 <= node && node <= 875);
cout << node << "\n";
for (i = 1; i <= node; i++) {
for (j = 1; j <= node; j++) {
printf("%c", grid[i][j]);
}
printf("\n");
}
}
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
Hibiki and Dita are in love with each other, but belong to communities that are in a long lasting conflict. Hibiki is deeply concerned with the state of affairs, and wants to figure out if his relationship with Dita is an act of love or an act of treason.
<image>
Hibiki prepared several binary features his decision will depend on, and built a three layer logical circuit on top of them, each layer consisting of one or more [logic gates](https://en.wikipedia.org/wiki/Logic_gate). Each gate in the circuit is either "or", "and", "nor" (not or) or "nand" (not and). Each gate in the first layer is connected to exactly two features. Each gate in the second layer is connected to exactly two gates in the first layer. The third layer has only one "or" gate, which is connected to all the gates in the second layer (in other words, the entire circuit produces 1 if and only if at least one gate in the second layer produces 1).
The problem is, Hibiki knows very well that when the person is in love, his ability to think logically degrades drastically. In particular, it is well known that when a person in love evaluates a logical circuit in his mind, every gate evaluates to a value that is the opposite of what it was supposed to evaluate to. For example, "or" gates return 1 if and only if both inputs are zero, "t{nand}" gates produce 1 if and only if both inputs are one etc.
In particular, the "or" gate in the last layer also produces opposite results, and as such if Hibiki is in love, the entire circuit produces 1 if and only if all the gates on the second layer produced 0.
Hibiki can’t allow love to affect his decision. He wants to know what is the smallest number of gates that needs to be removed from the second layer so that the output of the circuit for all possible inputs doesn't depend on whether Hibiki is in love or not.
Input
The first line contains three integers n, m, k (2 ≤ n, m ≤ 50; 1 ≤ k ≤ 50) — the number of input features, the number of gates in the first layer, and the number of gates in the second layer correspondingly.
The second line contains m pairs of strings separated by spaces describing the first layer. The first string in each pair describes the gate ("and", "or", "nand" or "nor"), and the second string describes the two input features the gate is connected two as a string consisting of exactly n characters, with exactly two characters (that correspond to the input features the gate is connected to) equal to 'x' and the remaining characters equal to ".'.
The third line contains k pairs of strings separated by spaces describing the second layer in the same format, where the strings that describe the input parameters have length m and correspond to the gates of the first layer.
Output
Print the number of gates that need to be removed from the second layer so that the output of the remaining circuit doesn't depend on whether Hibiki is in love or not.
If no matter how many gates are removed the output of the circuit continues to depend on Hibiki's feelings, print -1.
Examples
Input
2 2 2
and xx nand xx
and xx or xx
Output
1
Input
3 2 2
and xx. nor .xx
and xx nor xx
Output
-1
Input
4 4 5
nor x..x and ..xx and xx.. nand xx..
nand ..xx nor ..xx and xx.. nor ..xx or ..xx
Output
2
Note
In the first example the two gates in the first layer are connected to the same inputs, but first computes "and" while second computes "nand", and as such their output is always different no matter what the input is and whether Hibiki is in love or not. The second layer has "or" and "and" gates both connected to the two gates in the first layer. If Hibiki is not in love, the "and" gate will produce 0 and the "or" gate will produce 1 no matter what input features are equal to, with the final "or" gate in the third layer always producing the final answer of 1. If Hibiki is in love, "and" gate in the second layer will produce 1 and "or" gate will produce 0 no matter what the input is, with the final "or" gate in the third layer producing the final answer of 0. Thus, if both gates in the second layer are kept, the output of the circuit does depend on whether Hibiki is in love. If any of the two gates in the second layer is dropped, the output of the circuit will no longer depend on whether Hibiki is in love or not, and hence the answer is 1.
In the second example no matter what gates are left in the second layer, the output of the circuit will depend on whether Hibiki is in love or not.
In the third example if Hibiki keeps second, third and fourth gates in the second layer, the circuit will not depend on whether Hibiki is in love or not. Alternatively, he can keep the first and the last gates. The former requires removing two gates, the latter requires removing three gates, so the former is better, and the answer is 2.
### Response
```cpp
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c* x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
template <class c>
debug& operator<<(const c&) {
return *this;
}
};
const int AND = 0, OR = 1, NAND = 2, NOR = 3;
const int nax = 1005;
struct S {
int type;
S zmien() {
S he;
he.type = type ^ 1;
return he;
}
void read() {
static char sl[10];
scanf("%s", sl);
string s = string(sl);
if (s == "and")
type = AND;
else if (s == "or")
type = OR;
else if (s == "nand")
type = NAND;
else if (s == "nor")
type = NOR;
else {
cout << "unknown type: " << s << endl;
assert(false);
}
}
bool operator()(bool a, bool b) {
if (type == AND) return a & b;
if (type == OR) return a | b;
if (type == NAND) return !(a & b);
if (type == NOR) return !(a | b);
assert(false);
}
};
void read(pair<S, pair<int, int>>& p) {
p.first.read();
static char sl[105];
scanf("%s", sl);
int n = strlen(sl);
vector<int> w;
for (int i = 0; i < n; ++i)
if (sl[i] == 'x') w.push_back(i);
assert((int)w.size() == 2);
p.second = {w[0], w[1]};
}
vector<int> w[nax];
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
vector<pair<S, pair<int, int>>> one(m), two(k);
for (int i = 0; i < m; ++i) read(one[i]);
for (int i = 0; i < k; ++i) read(two[i]);
const int M = 40 * 1000;
vector<pair<vector<bool>, vector<bool>>> pre(M);
for (auto& p : pre) {
vector<bool> a(n), b(m), c(k), d(k);
for (int i = 0; i < n; ++i) a[i] = rand() % 2;
for (int i = 0; i < m; ++i)
b[i] = one[i].first(a[one[i].second.first], a[one[i].second.second]);
for (int i = 0; i < k; ++i)
c[i] = two[i].first(b[two[i].second.first], b[two[i].second.second]);
for (int i = 0; i < k; ++i)
d[i] =
two[i].first.zmien()(b[two[i].second.first], b[two[i].second.second]);
p = {c, d};
}
vector<bool> maybe(k, true);
for (auto& p : pre) {
auto& c = p.first;
auto& d = p.second;
debug() << " ["
<< "c"
": "
<< (c) << "] ";
for (int i = 0; i < k; ++i)
if (c[i] & d[i]) maybe[i] = false;
bool any = false;
for (int i = 0; i < k; ++i)
if (maybe[i])
if (c[i] | d[i]) any = true;
if (!any) {
puts("-1");
return 0;
}
}
vector<vector<bool>> e(k, vector<bool>(k));
for (auto& p : pre) {
auto& c = p.first;
auto& d = p.second;
debug() << " ["
<< "c"
": "
<< (c) << "] ";
debug() << " ["
<< "d"
": "
<< (d) << "] ";
debug();
for (int i = 0; i < k; ++i)
if (maybe[i])
for (int j = i + 1; j < k; ++j)
if (maybe[j])
if ((c[i] & d[j]) | (c[j] & d[i])) e[i][j] = e[j][i] = true;
}
for (int i = 0; i < k; ++i)
for (int j = i + 1; j < k; ++j)
if (e[i][j]) {
w[i].push_back(j);
w[j].push_back(i);
}
int answer = 0;
for (int i = 0; i < k; ++i)
if (!maybe[i]) ++answer;
vector<bool> vis(k);
vector<pair<vector<int>, vector<int>>> they;
vector<bool> taken(k);
for (int i = 0; i < k; ++i)
if (maybe[i] && !vis[i]) {
vector<int> A, B;
vector<int> kol{i};
vector<int> dist(k);
vis[i] = true;
for (int j = 0; j < (int)kol.size(); ++j) {
int a = kol[j];
if (dist[a] % 2)
A.push_back(a);
else
B.push_back(a);
for (int b : w[a])
if (!vis[b]) {
vis[b] = true;
dist[b] = dist[a] + 1;
kol.push_back(b);
}
}
if (A.size() < B.size()) swap(A, B);
they.push_back({A, B});
for (int x : A) taken[x] = true;
answer += (int)B.size();
}
bool yeah = true;
for (auto& p : pre) {
auto& c = p.first;
auto& d = p.second;
bool any = false;
for (int i = 0; i < k; ++i)
if (taken[i])
if (c[i] | d[i]) any = true;
if (!any) {
yeah = false;
break;
}
}
if (!yeah)
for (pair<vector<int>, vector<int>> p : they) {
int by = 1000000;
auto memo = taken;
for (int x : p.first) {
assert(taken[x]);
taken[x] = false;
}
for (int x : p.second) {
assert(!taken[x]);
taken[x] = true;
}
bool tu = true;
for (auto& p : pre) {
auto& c = p.first;
auto& d = p.second;
bool any = false;
for (int i = 0; i < k; ++i)
if (taken[i])
if (c[i] | d[i]) any = true;
if (!any) {
tu = false;
break;
}
}
if (tu)
by = min(by, (int)abs(int(p.first.size()) - int(p.second.size())));
taken = memo;
answer += by;
}
printf("%d\n", answer);
return 0;
for (int mask = 0; mask < (1 << k); ++mask) {
bool ok = true;
for (int i = 0; i < k; ++i)
if (mask & (1 << i))
if (!maybe[i]) ok = false;
if (!ok) continue;
for (int rep = 0; rep < 200; ++rep) {
vector<bool> a(n), b(m), c(k), d(k);
for (int i = 0; i < n; ++i) a[i] = rand() % 2;
for (int i = 0; i < m; ++i)
b[i] = one[i].first(a[one[i].second.first], a[one[i].second.second]);
for (int i = 0; i < k; ++i)
c[i] = two[i].first(b[two[i].second.first], b[two[i].second.second]);
for (int i = 0; i < k; ++i)
d[i] = two[i].first.zmien()(b[two[i].second.first],
b[two[i].second.second]);
bool raz = false, dwa = false;
for (int i = 0; i < k; ++i)
if (mask & (1 << i)) {
if (c[i]) raz = true;
if (d[i]) dwa = true;
}
if (raz && dwa) ok = false;
if (!raz && !dwa) ok = false;
if (!ok) break;
}
if (ok) answer = max(answer, __builtin_popcount(mask));
}
assert(answer != -1);
printf("%d\n", k - answer);
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
Wabbit is trying to move a box containing food for the rest of the zoo in the coordinate plane from the point (x_1,y_1) to the point (x_2,y_2).
He has a rope, which he can use to pull the box. He can only pull the box if he stands exactly 1 unit away from the box in the direction of one of two coordinate axes. He will pull the box to where he is standing before moving out of the way in the same direction by 1 unit.
<image>
For example, if the box is at the point (1,2) and Wabbit is standing at the point (2,2), he can pull the box right by 1 unit, with the box ending up at the point (2,2) and Wabbit ending at the point (3,2).
Also, Wabbit can move 1 unit to the right, left, up, or down without pulling the box. In this case, it is not necessary for him to be in exactly 1 unit away from the box. If he wants to pull the box again, he must return to a point next to the box. Also, Wabbit can't move to the point where the box is located.
Wabbit can start at any point. It takes 1 second to travel 1 unit right, left, up, or down, regardless of whether he pulls the box while moving.
Determine the minimum amount of time he needs to move the box from (x_1,y_1) to (x_2,y_2). Note that the point where Wabbit ends up at does not matter.
Input
Each test contains multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 1000): the number of test cases. The description of the test cases follows.
Each of the next t lines contains four space-separated integers x_1, y_1, x_2, y_2 (1 ≤ x_1, y_1, x_2, y_2 ≤ 10^9), describing the next test case.
Output
For each test case, print a single integer: the minimum time in seconds Wabbit needs to bring the box from (x_1,y_1) to (x_2,y_2).
Example
Input
2
1 2 2 2
1 1 2 2
Output
1
4
Note
In the first test case, the starting and the ending points of the box are (1,2) and (2,2) respectively. This is the same as the picture in the statement. Wabbit needs only 1 second to move as shown in the picture in the statement.
In the second test case, Wabbit can start at the point (2,1). He pulls the box to (2,1) while moving to (3,1). He then moves to (3,2) and then to (2,2) without pulling the box. Then, he pulls the box to (2,2) while moving to (2,3). It takes 4 seconds.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
if (x1 == x2) {
cout << abs(y1 - y2) << "\n";
} else if (y1 == y2) {
cout << abs(x1 - x2) << "\n";
} else {
long long int vt = abs(y1 - y2);
long long int hz = abs(x1 - x2);
long long int ans = 0;
if (vt > hz) {
ans += vt;
ans += hz - 1;
ans += 3;
} else {
ans += hz;
ans += vt - 1;
ans += 3;
}
cout << ans << "\n";
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int testcases;
cin >> testcases;
while (testcases--) {
solve();
}
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
In this problem, a n × m rectangular matrix a is called increasing if, for each row of i, when go from left to right, the values strictly increase (that is, a_{i,1}<a_{i,2}<...<a_{i,m}) and for each column j, when go from top to bottom, the values strictly increase (that is, a_{1,j}<a_{2,j}<...<a_{n,j}).
In a given matrix of non-negative integers, it is necessary to replace each value of 0 with some positive integer so that the resulting matrix is increasing and the sum of its elements is maximum, or find that it is impossible.
It is guaranteed that in a given value matrix all values of 0 are contained only in internal cells (that is, not in the first or last row and not in the first or last column).
Input
The first line contains integers n and m (3 ≤ n, m ≤ 500) — the number of rows and columns in the given matrix a.
The following lines contain m each of non-negative integers — the values in the corresponding row of the given matrix: a_{i,1}, a_{i,2}, ..., a_{i,m} (0 ≤ a_{i,j} ≤ 8000).
It is guaranteed that for all a_{i,j}=0, 1 < i < n and 1 < j < m are true.
Output
If it is possible to replace all zeros with positive numbers so that the matrix is increasing, print the maximum possible sum of matrix elements. Otherwise, print -1.
Examples
Input
4 5
1 3 5 6 7
3 0 7 0 9
5 0 0 0 10
8 9 10 11 12
Output
144
Input
3 3
1 2 3
2 0 4
4 5 6
Output
30
Input
3 3
1 2 3
3 0 4
4 5 6
Output
-1
Input
3 3
1 2 3
2 3 4
3 4 2
Output
-1
Note
In the first example, the resulting matrix is as follows:
1 3 5 6 7
3 6 7 8 9
5 7 8 9 10
8 9 10 11 12
In the second example, the value 3 must be put in the middle cell.
In the third example, the desired resultant matrix does not exist.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const double PI = 3.141592653589793238460;
const long long mod = 1e9 + 7;
void FAST() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
bool comp(const pair<int, int> &a, const pair<int, int> &b) {
return (a.first > b.second);
}
int main() {
FAST();
int n, m;
cin >> n >> m;
vector<vector<int> > a(n, vector<int>(m, 0));
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) cin >> a[i][j];
for (int i = n - 1; i >= 0; i--) {
for (int j = m - 1; j >= 0; j--) {
if (a[i][j] == 0) a[i][j] = min(a[i + 1][j] - 1, a[i][j + 1] - 1);
}
}
for (int i = 0; i < n; i++) {
for (int j = 1; j < m; j++) {
if (a[i][j] <= a[i][j - 1]) {
cout << -1 << '\n';
return 0;
}
}
}
for (int j = 0; j < m; j++) {
for (int i = 1; i < n; i++) {
if (a[i][j] <= a[i - 1][j]) {
cout << -1 << '\n';
return 0;
}
}
}
int sum = 0;
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) sum += a[i][j];
cout << sum << '\n';
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
Ujan decided to make a new wooden roof for the house. He has n rectangular planks numbered from 1 to n. The i-th plank has size a_i × 1 (that is, the width is 1 and the height is a_i).
Now, Ujan wants to make a square roof. He will first choose some of the planks and place them side by side in some order. Then he will glue together all of these planks by their vertical sides. Finally, he will cut out a square from the resulting shape in such a way that the sides of the square are horizontal and vertical.
For example, if Ujan had planks with lengths 4, 3, 1, 4 and 5, he could choose planks with lengths 4, 3 and 5. Then he can cut out a 3 × 3 square, which is the maximum possible. Note that this is not the only way he can obtain a 3 × 3 square.
<image>
What is the maximum side length of the square Ujan can get?
Input
The first line of input contains a single integer k (1 ≤ k ≤ 10), the number of test cases in the input.
For each test case, the first line contains a single integer n (1 ≤ n ≤ 1 000), the number of planks Ujan has in store. The next line contains n integers a_1, …, a_n (1 ≤ a_i ≤ n), the lengths of the planks.
Output
For each of the test cases, output a single integer, the maximum possible side length of the square.
Example
Input
4
5
4 3 1 4 5
4
4 4 4 4
3
1 1 1
5
5 5 1 1 5
Output
3
4
1
3
Note
The first sample corresponds to the example in the statement.
In the second sample, gluing all 4 planks will result in a 4 × 4 square.
In the third sample, the maximum possible square is 1 × 1 and can be taken simply as any of the planks.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
sort(a.begin(), a.end());
reverse(a.begin(), a.end());
int m = 0;
for (int i = 0; i < n; i++) m = max(min(a[i], i + 1), m);
cout << min(m, n) << endl;
}
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
In some country live wizards. They like to make weird bets.
Two wizards draw an acyclic directed graph with n vertices and m edges (the graph's vertices are numbered from 1 to n). A source is a vertex with no incoming edges, and a sink is the vertex with no outgoing edges. Note that a vertex could be the sink and the source simultaneously. In the wizards' graph the number of the sinks and the sources is the same.
Wizards numbered the sources in the order of increasing numbers of the vertices from 1 to k. The sinks are numbered from 1 to k in the similar way.
To make a bet, they, as are real wizards, cast a spell, which selects a set of k paths from all sources to the sinks in such a way that no two paths intersect at the vertices. In this case, each sink has exactly one path going to it from exactly one source. Let's suppose that the i-th sink has a path going to it from the ai's source. Then let's call pair (i, j) an inversion if i < j and ai > aj. If the number of inversions among all possible pairs (i, j), such that (1 ≤ i < j ≤ k), is even, then the first wizard wins (the second one gives him one magic coin). Otherwise, the second wizard wins (he gets one magic coin from the first one).
Our wizards are captured with feverish excitement, so they kept choosing new paths again and again for so long that eventually they have chosen every possible set of paths for exactly once. The two sets of non-intersecting pathes are considered to be different, if and only if there is an edge, which lies at some path in one set and doesn't lie at any path of another set. To check their notes, they asked you to count the total winnings of the first player for all possible sets of paths modulo a prime number p.
Input
The first line contains three space-separated integers n, m, p (1 ≤ n ≤ 600, 0 ≤ m ≤ 105, 2 ≤ p ≤ 109 + 7). It is guaranteed that p is prime number.
Next m lines contain edges of the graph. Each line contains a pair of space-separated integers, ai bi — an edge from vertex ai to vertex bi. It is guaranteed that the graph is acyclic and that the graph contains the same number of sources and sinks. Please note that the graph can have multiple edges.
Output
Print the answer to the problem — the total winnings of the first player modulo a prime number p. Please note that the winnings may be negative, but the modulo residue must be non-negative (see the sample).
Examples
Input
4 2 1000003
1 3
2 4
Output
1
Input
4 2 1000003
4 1
3 2
Output
1000002
Input
4 4 1000003
2 1
2 4
3 1
3 4
Output
0
Input
6 5 1000003
1 4
1 5
1 6
2 6
3 6
Output
0
Input
5 2 1000003
5 1
3 4
Output
1
Note
In the first sample, there is exactly one set of paths — <image>. The number of inversions is 0, which is an even number. Therefore, the first wizard gets 1 coin.
In the second sample there is exactly one set of paths — <image>. There is exactly one inversion. Therefore, the first wizard gets -1 coin. <image>.
In the third sample, there are two sets of paths, which are counted with opposite signs.
In the fourth sample there are no set of paths at all.
In the fifth sample, there are three sources — the vertices with the numbers (2, 3, 5) and three sinks — the vertices with numbers (1, 2, 4). For a single set of paths <image> are 2 inversions, that is, their number is even.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 600;
int n, m, x, y, p, cnt;
int Ind[MAXN + 5], Outd[MAXN + 5];
int s[MAXN + 5][MAXN + 5];
int tmp[MAXN + 5], f[MAXN + 5][MAXN + 5];
vector<int> Graph[MAXN + 5];
vector<int> S, T;
int Mo(long long x) { return (x % p + p) % p; }
void print(int x = 0) {
if (x) printf("%d\n", x);
for (int i = 1; i <= cnt; i++) {
for (int j = 1; j <= cnt; j++) printf("%d ", f[i][j]);
printf("\n");
}
printf("\n");
}
int Gauss() {
int Sign = 1;
for (int i = 1; i <= cnt; i++) {
for (int j = i + 1; j <= cnt; j++) {
int A = f[i][i], B = f[j][i];
while (B) {
int t = A / B;
A %= B;
swap(A, B);
for (int k = i; k <= n; k++)
f[i][k] = Mo(1ll * f[i][k] - 1ll * t * f[j][k]);
swap(f[i], f[j]);
Sign *= -1;
}
}
if (!f[i][i]) return 0;
}
int Ans = 1;
for (int i = 1; i <= cnt; i++) Ans = (1ll * Ans * f[i][i]) % p;
return Mo(1ll * Ans * Sign);
}
bool vis[MAXN + 5];
void dfs(int u) {
vis[u] = 1;
if (!Outd[u]) s[u][u] = 1;
for (int i = 0; i < Graph[u].size(); i++) {
int v = Graph[u][i];
if (!vis[v]) dfs(v);
for (int j = 0; j < T.size(); j++)
s[u][T[j]] = Mo(1ll * s[u][T[j]] + s[v][T[j]]);
}
}
int main() {
scanf("%d %d %d", &n, &m, &p);
for (int i = 1; i <= m; i++) {
scanf("%d %d", &x, &y);
Graph[x].push_back(y);
Outd[x]++, Ind[y]++;
}
for (int i = 1; i <= n; i++) {
if (!Ind[i]) S.push_back(i);
if (!Outd[i]) T.push_back(i);
}
for (int i = 1; i <= n; i++)
if (!Ind[i]) dfs(i);
for (int i = 0; i < S.size(); i++)
for (int j = 0; j < T.size(); j++) f[i + 1][j + 1] = s[S[i]][T[j]];
cnt = S.size();
printf("%d", Gauss());
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
Joker returns to Gotham City to execute another evil plan. In Gotham City, there are N street junctions (numbered from 1 to N) and M streets (numbered from 1 to M). Each street connects two distinct junctions, and two junctions are connected by at most one street.
For his evil plan, Joker needs to use an odd number of streets that together form a cycle. That is, for a junction S and an even positive integer k, there is a sequence of junctions S, s_1, …, s_k, S such that there are streets connecting (a) S and s_1, (b) s_k and S, and (c) s_{i-1} and s_i for each i = 2, …, k.
However, the police are controlling the streets of Gotham City. On each day i, they monitor a different subset of all streets with consecutive numbers j: l_i ≤ j ≤ r_i. These monitored streets cannot be a part of Joker's plan, of course. Unfortunately for the police, Joker has spies within the Gotham City Police Department; they tell him which streets are monitored on which day. Now Joker wants to find out, for some given number of days, whether he can execute his evil plan. On such a day there must be a cycle of streets, consisting of an odd number of streets which are not monitored on that day.
Input
The first line of the input contains three integers N, M, and Q (1 ≤ N, M, Q ≤ 200 000): the number of junctions, the number of streets, and the number of days to be investigated. The following M lines describe the streets. The j-th of these lines (1 ≤ j ≤ M) contains two junction numbers u and v (u ≠ v), saying that street j connects these two junctions. It is guaranteed that any two junctions are connected by at most one street. The following Q lines contain two integers l_i and r_i, saying that all streets j with l_i ≤ j ≤ r_i are checked by the police on day i (1 ≤ i ≤ Q).
Output
Your output is to contain Q lines. Line i (1 ≤ i ≤ Q) contains "YES" if Joker can execute his plan on day i, or "NO" otherwise.
Scoring
Subtasks:
1. (6 points) 1 ≤ N, M, Q ≤ 200
2. (8 points) 1 ≤ N, M, Q ≤ 2 000
3. (25 points) l_i = 1 for i = 1, …, Q
4. (10 points) l_i ≤ 200 for i = 1, …, Q
5. (22 points) Q ≤ 2 000
6. (29 points) No further constraints
Example
Input
6 8 2
1 3
1 5
1 6
2 5
2 6
3 4
3 5
5 6
4 8
4 7
Output
NO
YES
Note
The graph in the example test:
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct DSU {
vector<int> rank, link;
vector<int> stk, chkp;
DSU(int n) : rank(2 * n, 0), link(2 * n, -1) {}
int find(int x) {
while (link[x] != -1) x = link[x];
return x;
}
void unite(int a, int b) {
a = find(a);
b = find(b);
if (a == b) return;
if (rank[a] > rank[b]) swap(a, b);
stk.push_back(a);
link[a] = b;
rank[b] += (rank[a] == rank[b]);
}
bool Try(int a, int b) {
if (find(2 * a + 1) == find(2 * b + 1)) return false;
return true;
}
void Unite(int a, int b) {
chkp.push_back(stk.size());
unite(2 * a, 2 * b + 1);
unite(2 * a + 1, 2 * b);
assert(find(2 * a) != find(2 * a + 1));
}
void Undo() {
for (int i = chkp.back(); i < (int)stk.size(); ++i) link[stk[i]] = -1;
stk.resize(chkp.back());
chkp.pop_back();
}
};
struct Upd {
int type, a, b;
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m, q;
cin >> n >> m >> q;
vector<pair<int, int>> edges;
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
edges.emplace_back(a - 1, b - 1);
}
DSU dsu(n);
vector<Upd> upds, tmp[2];
auto pop = [&]() {
if (upds.back().type == 1) {
while (upds.size()) {
auto upd = upds.back();
upds.pop_back();
dsu.Undo();
tmp[upd.type].push_back(upd);
if (tmp[0].size() == tmp[1].size()) break;
}
if (tmp[0].empty()) {
assert(upds.empty());
for (auto& upd : tmp[1]) {
upd.type = 0;
dsu.Unite(upd.a, upd.b);
}
swap(tmp[1], upds);
} else {
reverse(tmp[0].begin(), tmp[0].end());
reverse(tmp[1].begin(), tmp[1].end());
for (int z = 1; z >= 0; --z) {
for (auto upd : tmp[z]) {
dsu.Unite(upd.a, upd.b);
upds.push_back(upd);
}
}
tmp[0].clear();
tmp[1].clear();
}
}
assert(upds.back().type == 0);
upds.pop_back();
dsu.Undo();
};
auto push = [&](int a, int b) {
upds.push_back(Upd{1, a, b});
dsu.Unite(a, b);
};
vector<int> dp(2 * m);
int lbound = 0;
for (int i = 0; i < 2 * m; ++i) {
auto [a, b] = edges[i % m];
while (!dsu.Try(a, b)) {
pop();
++lbound;
}
push(a, b);
dp[i] = lbound;
}
for (int i = 0; i < q; ++i) {
int a, b;
cin >> a >> b;
--a;
--b;
if (dp[a + m - 1] <= b + 1)
cout << "NO\n";
else
cout << "YES\n";
}
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
The last stage of Football World Cup is played using the play-off system.
There are n teams left in this stage, they are enumerated from 1 to n. Several rounds are held, in each round the remaining teams are sorted in the order of their ids, then the first in this order plays with the second, the third — with the fourth, the fifth — with the sixth, and so on. It is guaranteed that in each round there is even number of teams. The winner of each game advances to the next round, the loser is eliminated from the tournament, there are no draws. In the last round there is the only game with two remaining teams: the round is called the Final, the winner is called the champion, and the tournament is over.
Arkady wants his two favorite teams to play in the Final. Unfortunately, the team ids are already determined, and it may happen that it is impossible for teams to meet in the Final, because they are to meet in some earlier stage, if they are strong enough. Determine, in which round the teams with ids a and b can meet.
Input
The only line contains three integers n, a and b (2 ≤ n ≤ 256, 1 ≤ a, b ≤ n) — the total number of teams, and the ids of the teams that Arkady is interested in.
It is guaranteed that n is such that in each round an even number of team advance, and that a and b are not equal.
Output
In the only line print "Final!" (without quotes), if teams a and b can meet in the Final.
Otherwise, print a single integer — the number of the round in which teams a and b can meet. The round are enumerated from 1.
Examples
Input
4 1 2
Output
1
Input
8 2 6
Output
Final!
Input
8 7 5
Output
2
Note
In the first example teams 1 and 2 meet in the first round.
In the second example teams 2 and 6 can only meet in the third round, which is the Final, if they win all their opponents in earlier rounds.
In the third example the teams with ids 7 and 5 can meet in the second round, if they win their opponents in the first round.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n, a, b;
cin >> n >> a >> b;
int level = 0;
while (a != b) {
a = (a + 1) / 2;
b = (b + 1) / 2;
level++;
}
if ((1 << level) == n)
cout << "Final!" << endl;
else
cout << level << endl;
return 0;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
Little Chris is participating in a graph cutting contest. He's a pro. The time has come to test his skills to the fullest.
Chris is given a simple undirected connected graph with n vertices (numbered from 1 to n) and m edges. The problem is to cut it into edge-distinct paths of length 2. Formally, Chris has to partition all edges of the graph into pairs in such a way that the edges in a single pair are adjacent and each edge must be contained in exactly one pair.
For example, the figure shows a way Chris can cut a graph. The first sample test contains the description of this graph.
<image>
You are given a chance to compete with Chris. Find a way to cut the given graph or determine that it is impossible!
Input
The first line of input contains two space-separated integers n and m (1 ≤ n, m ≤ 105), the number of vertices and the number of edges in the graph. The next m lines contain the description of the graph's edges. The i-th line contains two space-separated integers ai and bi (1 ≤ ai, bi ≤ n; ai ≠ bi), the numbers of the vertices connected by the i-th edge. It is guaranteed that the given graph is simple (without self-loops and multi-edges) and connected.
Note: since the size of the input and output could be very large, don't use slow output techniques in your language. For example, do not use input and output streams (cin, cout) in C++.
Output
If it is possible to cut the given graph into edge-distinct paths of length 2, output <image> lines. In the i-th line print three space-separated integers xi, yi and zi, the description of the i-th path. The graph should contain this path, i.e., the graph should contain edges (xi, yi) and (yi, zi). Each edge should appear in exactly one path of length 2. If there are multiple solutions, output any of them.
If it is impossible to cut the given graph, print "No solution" (without quotes).
Examples
Input
8 12
1 2
2 3
3 4
4 1
1 3
2 4
3 5
3 6
5 6
6 7
6 8
7 8
Output
1 2 4
1 3 2
1 4 3
5 3 6
5 6 8
6 7 8
Input
3 3
1 2
2 3
3 1
Output
No solution
Input
3 2
1 2
2 3
Output
1 2 3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
struct node {
int x, y, z;
node(int x, int y, int z) : x(x), y(y), z(z) {}
};
vector<int> adj[N];
vector<node> ans;
int vis[N];
int tot;
int dfs(int u, int fa) {
vis[u] = ++tot;
int a = 0;
int s = adj[u].size();
for (int i = 0; i < s; i++) {
int v = adj[u][i];
if (v == fa) continue;
if (!vis[v]) {
if (dfs(v, u)) continue;
if (!a)
a = v;
else {
ans.push_back(node(v, u, a));
a = 0;
}
} else if (vis[v] < vis[u]) {
if (!a)
a = v;
else {
ans.push_back(node(v, u, a));
a = 0;
}
}
}
if (a) {
ans.push_back(node(a, u, fa));
return 1;
}
return 0;
}
int main() {
int n, m, u, v, i, j;
while (~scanf("%d%d", &n, &m)) {
for (i = 0; i < m; i++) {
scanf("%d%d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
if (m & 1) {
printf("No solution\n");
continue;
}
tot = 0;
dfs(1, -1);
int k = ans.size();
for (i = 0; i < k; i++) {
node tmp = ans[i];
printf("%d %d %d\n", tmp.x, tmp.y, tmp.z);
}
}
return 0;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
Compute A \times B, truncate its fractional part, and print the result as an integer.
Constraints
* 0 \leq A \leq 10^{15}
* 0 \leq B < 10
* A is an integer.
* B is a number with two digits after the decimal point.
Input
Input is given from Standard Input in the following format:
A B
Output
Print the answer as an integer.
Examples
Input
198 1.10
Output
217
Input
1 0.01
Output
0
Input
1000000000000000 9.99
Output
9990000000000000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long double A,B;
long long S=0;
cin >> A>>B;
S=A*B;
cout << S << endl;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
Polycarpus has a finite sequence of opening and closing brackets. In order not to fall asleep in a lecture, Polycarpus is having fun with his sequence. He is able to perform two operations:
* adding any bracket in any position (in the beginning, the end, or between any two existing brackets);
* cyclic shift — moving the last bracket from the end of the sequence to the beginning.
Polycarpus can apply any number of operations to his sequence and adding a cyclic shift in any order. As a result, he wants to get the correct bracket sequence of the minimum possible length. If there are several such sequences, Polycarpus is interested in the lexicographically smallest one. Help him find such a sequence.
Acorrect bracket sequence is a sequence of opening and closing brackets, from which you can get a correct arithmetic expression by adding characters "1" and "+" . Each opening bracket must correspond to a closed one. For example, the sequences "(())()", "()", "(()(()))" are correct and ")(", "(()" and "(()))(" are not.
The sequence a1 a2... an is lexicographically smaller than sequence b1 b2... bn, if there is such number i from 1 to n, thatak = bk for 1 ≤ k < i and ai < bi. Consider that "(" < ")".
Input
The first line contains Polycarpus's sequence consisting of characters "(" and ")". The length of a line is from 1 to 1 000 000.
Output
Print a correct bracket sequence of the minimum length that Polycarpus can obtain by his operations. If there are multiple such sequences, print the lexicographically minimum one.
Examples
Input
()(())
Output
(())()
Input
()(
Output
(())
Note
The sequence in the first example is already correct, but to get the lexicographically minimum answer, you need to perform four cyclic shift operations. In the second example you need to add a closing parenthesis between the second and third brackets and make a cyclic shift. You can first make the shift, and then add the bracket at the end.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, s[2000100];
bool vis[2000100];
char t[2000100];
int sa[2000100], rnk[2000100], tmp[2000100], cnt[2000100];
void build(char *s) {
int n = strlen(s) + 1, m = 256;
int *x = rnk, *y = tmp, *z;
for (int i = 0; i < m; i++) cnt[i] = 0;
for (int i = 0; i < n; i++) cnt[x[i] = s[i]]++;
for (int i = 1; i < m; i++) cnt[i] += cnt[i - 1];
for (int i = n - 1; i >= 0; i--) sa[--cnt[x[i]]] = i;
for (int j = 1, p = 1; p < n; j <<= 1, m = p) {
p = 0;
for (int i = n - j; i < n; i++) y[p++] = i;
for (int i = 0; i < n; i++)
if (sa[i] >= j) y[p++] = sa[i] - j;
for (int i = 0; i < m; i++) cnt[i] = 0;
for (int i = 0; i < n; i++) cnt[x[i]]++;
for (int i = 1; i < m; i++) cnt[i] += cnt[i - 1];
for (int i = n - 1; i >= 0; i--) sa[--cnt[x[y[i]]]] = y[i];
z = x, x = y, y = z;
x[sa[0]] = 0, p = 1;
for (int i = 1; i < n; i++)
x[sa[i]] = (y[sa[i]] == y[sa[i - 1]] && y[sa[i] + j] == y[sa[i - 1] + j])
? p - 1
: p++;
}
for (int i = 0; i < n; i++) rnk[sa[i]] = i;
}
int main() {
scanf("%s", t + 1);
n = strlen(t + 1);
int mn = 0;
for (int i = 1; i <= n; i++) {
s[i] = s[i - 1];
if (t[i] == '(')
s[i]++;
else
s[i]--;
mn = min(mn, s[i]);
}
for (int i = 1; i <= n; i++) t[n + i] = t[i], s[i + n] = s[i] + s[n];
int dn = 0;
if (s[n] < 0) dn = -s[n];
build(t + 1);
multiset<int> S;
for (int i = n + 1; i <= 2 * n; i++) S.insert(s[i]);
int k, p = 1e9;
for (int i = n; i >= 0; i--) {
int t = *S.begin();
S.erase(S.find(s[i + n]));
if (t - s[i] + dn >= 0) {
if (rnk[i] < p) p = rnk[i], k = i + 1;
}
S.insert(s[i]);
}
int sum = s[n];
if (sum < 0)
for (int i = sum; i < 0; i++) putchar('(');
for (int i = 0; i < n; i++) putchar(t[k + i]);
if (sum > 0)
for (int i = 0; i < sum; i++) putchar(')');
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
There is a robot staying at X=0 on the Ox axis. He has to walk to X=n. You are controlling this robot and controlling how he goes. The robot has a battery and an accumulator with a solar panel.
The i-th segment of the path (from X=i-1 to X=i) can be exposed to sunlight or not. The array s denotes which segments are exposed to sunlight: if segment i is exposed, then s_i = 1, otherwise s_i = 0.
The robot has one battery of capacity b and one accumulator of capacity a. For each segment, you should choose which type of energy storage robot will use to go to the next point (it can be either battery or accumulator). If the robot goes using the battery, the current charge of the battery is decreased by one (the robot can't use the battery if its charge is zero). And if the robot goes using the accumulator, the current charge of the accumulator is decreased by one (and the robot also can't use the accumulator if its charge is zero).
If the current segment is exposed to sunlight and the robot goes through it using the battery, the charge of the accumulator increases by one (of course, its charge can't become higher than it's maximum capacity).
If accumulator is used to pass some segment, its charge decreases by 1 no matter if the segment is exposed or not.
You understand that it is not always possible to walk to X=n. You want your robot to go as far as possible. Find the maximum number of segments of distance the robot can pass if you control him optimally.
Input
The first line of the input contains three integers n, b, a (1 ≤ n, b, a ≤ 2 ⋅ 10^5) — the robot's destination point, the battery capacity and the accumulator capacity, respectively.
The second line of the input contains n integers s_1, s_2, ..., s_n (0 ≤ s_i ≤ 1), where s_i is 1 if the i-th segment of distance is exposed to sunlight, and 0 otherwise.
Output
Print one integer — the maximum number of segments the robot can pass if you control him optimally.
Examples
Input
5 2 1
0 1 0 1 0
Output
5
Input
6 2 1
1 0 0 1 0 1
Output
3
Note
In the first example the robot can go through the first segment using the accumulator, and charge levels become b=2 and a=0. The second segment can be passed using the battery, and charge levels become b=1 and a=1. The third segment can be passed using the accumulator, and charge levels become b=1 and a=0. The fourth segment can be passed using the battery, and charge levels become b=0 and a=1. And the fifth segment can be passed using the accumulator.
In the second example the robot can go through the maximum number of segments using battery two times and accumulator one time in any order.
### Response
```cpp
#include <bits/stdc++.h>
int n, b, a;
std::vector<int> A;
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(0);
std::cin >> n >> b >> a;
A.resize(n);
for (int i = 0; i < (n); ++i) std::cin >> A[i];
int ca = a;
for (int i = 0; i < (n); ++i) {
if (ca == 0 && b == 0) {
std::cout << i << "\n";
return 0;
}
if (A[i] == 1) {
if (b > 0 && ca < a)
b--, ca++;
else
ca--;
} else {
if (ca > 0)
ca--;
else
b--;
}
}
std::cout << n;
return 0;
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
Vasya has a non-negative integer n. He wants to round it to nearest integer, which ends up with 0. If n already ends up with 0, Vasya considers it already rounded.
For example, if n = 4722 answer is 4720. If n = 5 Vasya can round it to 0 or to 10. Both ways are correct.
For given n find out to which integer will Vasya round it.
Input
The first line contains single integer n (0 ≤ n ≤ 109) — number that Vasya has.
Output
Print result of rounding n. Pay attention that in some cases answer isn't unique. In that case print any correct answer.
Examples
Input
5
Output
0
Input
113
Output
110
Input
1000000000
Output
1000000000
Input
5432359
Output
5432360
Note
In the first example n = 5. Nearest integers, that ends up with zero are 0 and 10. Any of these answers is correct, so you can print 0 or 10.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
char a[15];
int b = 0;
memset(a, 0, sizeof(a));
scanf("%s", a);
int lo = strlen(a);
if (a[lo - 1] > '5') {
if (lo > 1)
a[lo - 2]++;
else {
b = 1;
}
}
a[lo - 1] = '0';
for (int i = lo; i >= 0; i--) {
if (a[i] > '9') {
if (i == 0) {
b = 1;
a[0] -= 10;
break;
}
a[i - 1]++;
a[i] -= 10;
}
}
if (b) printf("%d", b);
printf("%s", a);
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
The only difference between easy and hard versions is the maximum value of n.
You are given a positive integer number n. You really love good numbers so you want to find the smallest good number greater than or equal to n.
The positive integer is called good if it can be represented as a sum of distinct powers of 3 (i.e. no duplicates of powers of 3 are allowed).
For example:
* 30 is a good number: 30 = 3^3 + 3^1,
* 1 is a good number: 1 = 3^0,
* 12 is a good number: 12 = 3^2 + 3^1,
* but 2 is not a good number: you can't represent it as a sum of distinct powers of 3 (2 = 3^0 + 3^0),
* 19 is not a good number: you can't represent it as a sum of distinct powers of 3 (for example, the representations 19 = 3^2 + 3^2 + 3^0 = 3^2 + 3^1 + 3^1 + 3^1 + 3^0 are invalid),
* 20 is also not a good number: you can't represent it as a sum of distinct powers of 3 (for example, the representation 20 = 3^2 + 3^2 + 3^0 + 3^0 is invalid).
Note, that there exist other representations of 19 and 20 as sums of powers of 3 but none of them consists of distinct powers of 3.
For the given positive integer n find such smallest m (n ≤ m) that m is a good number.
You have to answer q independent queries.
Input
The first line of the input contains one integer q (1 ≤ q ≤ 500) — the number of queries. Then q queries follow.
The only line of the query contains one integer n (1 ≤ n ≤ 10^4).
Output
For each query, print such smallest integer m (where n ≤ m) that m is a good number.
Example
Input
7
1
2
6
13
14
3620
10000
Output
1
3
9
13
27
6561
19683
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long p[50];
p[0] = 1;
long long cumsum[50];
cumsum[0] = 1;
for (long long i = 1; i <= 38; i++) {
p[i] = p[i - 1] * 3;
cumsum[i] = cumsum[i - 1] + p[i];
}
long long t;
scanf("%lld", &t);
while (t--) {
long long n;
scanf("%lld", &n);
long long ans = 0;
long long x = n;
for (long long i = 38; i >= 1; i--) {
if (cumsum[i - 1] >= x) continue;
x = x - p[i];
ans = ans + p[i];
}
if (x > 0) {
ans++;
}
cout << ans << "\n";
}
}
``` |
### Prompt
Create a solution in CPP for the following problem:
The World Programming Olympics Medal is a metal disk, consisting of two parts: the first part is a ring with outer radius of r1 cm, inner radius of r2 cm, (0 < r2 < r1) made of metal with density p1 g/cm3. The second part is an inner disk with radius r2 cm, it is made of metal with density p2 g/cm3. The disk is nested inside the ring.
The Olympic jury decided that r1 will take one of possible values of x1, x2, ..., xn. It is up to jury to decide which particular value r1 will take. Similarly, the Olympic jury decided that p1 will take one of possible value of y1, y2, ..., ym, and p2 will take a value from list z1, z2, ..., zk.
According to most ancient traditions the ratio between the outer ring mass mout and the inner disk mass min must equal <image>, where A, B are constants taken from ancient books. Now, to start making medals, the jury needs to take values for r1, p1, p2 and calculate the suitable value of r2.
The jury wants to choose the value that would maximize radius r2. Help the jury find the sought value of r2. Value r2 doesn't have to be an integer.
Medal has a uniform thickness throughout the area, the thickness of the inner disk is the same as the thickness of the outer ring.
Input
The first input line contains an integer n and a sequence of integers x1, x2, ..., xn. The second input line contains an integer m and a sequence of integers y1, y2, ..., ym. The third input line contains an integer k and a sequence of integers z1, z2, ..., zk. The last line contains two integers A and B.
All numbers given in the input are positive and do not exceed 5000. Each of the three sequences contains distinct numbers. The numbers in the lines are separated by spaces.
Output
Print a single real number — the sought value r2 with absolute or relative error of at most 10 - 6. It is guaranteed that the solution that meets the problem requirements exists.
Examples
Input
3 1 2 3
1 2
3 3 2 1
1 2
Output
2.683281573000
Input
4 2 3 6 4
2 1 2
3 10 6 8
2 1
Output
2.267786838055
Note
In the first sample the jury should choose the following values: r1 = 3, p1 = 2, p2 = 1.
### Response
```cpp
#include <bits/stdc++.h>
const int MAXN = 5050;
int n, m, k;
int x[MAXN];
int y[MAXN];
int z[MAXN];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &x[i]);
scanf("%d", &m);
for (int i = 0; i < m; i++) scanf("%d", &y[i]);
scanf("%d", &k);
for (int i = 0; i < k; i++) scanf("%d", &z[i]);
int A, B;
scanf("%d%d", &A, &B);
int r1 = x[0];
for (int i = 1; i < n; i++)
if (x[i] > r1) r1 = x[i];
double r2 = 0;
for (int i = 0; i < m; i++)
for (int j = 0; j < k; j++)
if (double((double)r1 * (double)r1 * (double)B * (double)y[i]) /
double((double)A * (double)z[j] + (double)B * (double)y[i]) >
r2)
r2 = double((double)r1 * (double)r1 * (double)B * (double)y[i]) /
double((double)A * (double)z[j] + (double)B * (double)y[i]);
printf("%.8lf\n", sqrt(r2));
return 0;
}
``` |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.