text
stringlengths 424
69.5k
|
|---|
### Prompt
Please provide a cpp coded solution to the problem described below:
You are given a grid with n rows and m columns, where each cell has a non-negative integer written on it. We say the grid is good if for each cell the following condition holds: if it has a number k > 0 written on it, then exactly k of its neighboring cells have a number greater than 0 written on them. Note that if the number in the cell is 0, there is no such restriction on neighboring cells.
You are allowed to take any number in the grid and increase it by 1. You may apply this operation as many times as you want, to any numbers you want. Perform some operations (possibly zero) to make the grid good, or say that it is impossible. If there are multiple possible answers, you may find any of them.
Two cells are considered to be neighboring if they have a common edge.
Input
The input consists of multiple test cases. The first line contains an integer t (1 β€ t β€ 5000) β the number of test cases. The description of the test cases follows.
The first line of each test case contains two integers n and m (2 β€ n, m β€ 300) β the number of rows and columns, respectively.
The following n lines contain m integers each, the j-th element in the i-th line a_{i, j} is the number written in the j-th cell of the i-th row (0 β€ a_{i, j} β€ 10^9).
It is guaranteed that the sum of n β
m over all test cases does not exceed 10^5.
Output
If it is impossible to obtain a good grid, print a single line containing "NO".
Otherwise, print a single line containing "YES", followed by n lines each containing m integers, which describe the final state of the grid. This final grid should be obtainable from the initial one by applying some operations (possibly zero).
If there are multiple possible answers, you may print any of them.
Example
Input
5
3 4
0 0 0 0
0 1 0 0
0 0 0 0
2 2
3 0
0 0
2 2
0 0
0 0
2 3
0 0 0
0 4 0
4 4
0 0 0 0
0 2 0 1
0 0 0 0
0 0 0 0
Output
YES
0 0 0 0
0 1 1 0
0 0 0 0
NO
YES
0 0
0 0
NO
YES
0 1 0 0
1 4 2 1
0 2 0 0
1 3 1 0
Note
In the first test case, we can obtain the resulting grid by increasing the number in row 2, column 3 once. Both of the cells that contain 1 have exactly one neighbor that is greater than zero, so the grid is good. Many other solutions exist, such as the grid
$$$0\;1\;0\;0 0\;2\;1\;0 0\;0\;0\;0$$$
All of them are accepted as valid answers.
In the second test case, it is impossible to make the grid good.
In the third test case, notice that no cell has a number greater than zero on it, so the grid is automatically good.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int dx[4] = {0, -1, 0, 1};
const int dy[4] = {1, 0, -1, 0};
int n, m;
bool is_corr(int a, int b) { return a >= 0 && a < n && b >= 0 && b < m; }
signed main() {
int t;
cin >> t;
while (t--) {
cin >> n >> m;
bool pos = true;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
int a;
cin >> a;
int b = 0;
for (int ii = 0; ii < 4; ++ii) {
if (is_corr(i + dx[ii], j + dy[ii])) {
++b;
}
}
if (b < a) {
pos = false;
}
}
}
if (pos) {
cout << "YES\n";
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
int b = 0;
for (int ii = 0; ii < 4; ++ii) {
if (is_corr(i + dx[ii], j + dy[ii])) {
++b;
}
}
cout << b << " ";
}
cout << "\n";
}
} else {
cout << "NO\n";
}
}
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
When Valera has got some free time, he goes to the library to read some books. Today he's got t free minutes to read. That's why Valera took n books in the library and for each book he estimated the time he is going to need to read it. Let's number the books by integers from 1 to n. Valera needs ai minutes to read the i-th book.
Valera decided to choose an arbitrary book with number i and read the books one by one, starting from this book. In other words, he will first read book number i, then book number i + 1, then book number i + 2 and so on. He continues the process until he either runs out of the free time or finishes reading the n-th book. Valera reads each book up to the end, that is, he doesn't start reading the book if he doesn't have enough free time to finish reading it.
Print the maximum number of books Valera can read.
Input
The first line contains two integers n and t (1 β€ n β€ 105; 1 β€ t β€ 109) β the number of books and the number of free minutes Valera's got. The second line contains a sequence of n integers a1, a2, ..., an (1 β€ ai β€ 104), where number ai shows the number of minutes that the boy needs to read the i-th book.
Output
Print a single integer β the maximum number of books Valera can read.
Examples
Input
4 5
3 1 2 1
Output
3
Input
3 3
2 2 3
Output
1
### Response
```cpp
#include <bits/stdc++.h>
long long a[100010];
int main() {
long long n, m;
scanf("%I64d%I64d", &n, &m);
long long resu = 0;
long long time = 0;
long long i;
long long cnt;
a[0] = 0;
cnt = 1;
for (i = 1; i <= n; i++) {
scanf("%I64d", &a[i]);
time += a[i];
while (cnt <= i && time > m) {
time -= a[cnt];
cnt++;
}
if (i - cnt + 1 > resu) resu = i - cnt + 1;
}
printf("%I64d\n", resu);
return 0;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
Recently Anton found a box with digits in his room. There are k2 digits 2, k3 digits 3, k5 digits 5 and k6 digits 6.
Anton's favorite integers are 32 and 256. He decided to compose this integers from digits he has. He wants to make the sum of these integers as large as possible. Help him solve this task!
Each digit can be used no more than once, i.e. the composed integers should contain no more than k2 digits 2, k3 digits 3 and so on. Of course, unused digits are not counted in the sum.
Input
The only line of the input contains four integers k2, k3, k5 and k6 β the number of digits 2, 3, 5 and 6 respectively (0 β€ k2, k3, k5, k6 β€ 5Β·106).
Output
Print one integer β maximum possible sum of Anton's favorite integers that can be composed using digits from the box.
Examples
Input
5 1 3 4
Output
800
Input
1 1 1 1
Output
256
Note
In the first sample, there are five digits 2, one digit 3, three digits 5 and four digits 6. Anton can compose three integers 256 and one integer 32 to achieve the value 256 + 256 + 256 + 32 = 800. Note, that there is one unused integer 2 and one unused integer 6. They are not counted in the answer.
In the second sample, the optimal answer is to create on integer 256, thus the answer is 256.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, c, d;
cin >> a >> b >> c >> d;
long long f = min(a, min(c, d));
long long k = min(a, b);
int ans1 = 0, ans2 = 0;
ans1 = f * 256 + min(a - f, b) * 32;
ans2 = min(a, b) * 32 + min(a - k, min(c, d)) * 256;
cout << max(ans1, ans2);
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
Revised
The current era, Heisei, will end on April 30, 2019, and a new era will begin the next day. The day after the last day of Heisei will be May 1, the first year of the new era.
In the system developed by the ACM-ICPC OB / OG Association (Japanese Alumni Group; JAG), the date uses the Japanese calendar (the Japanese calendar that expresses the year by the era name and the number of years following it). It is saved in the database in the format of "d days". Since this storage format cannot be changed, JAG saves the date expressed in the Japanese calendar in the database assuming that the era name does not change, and converts the date to the format using the correct era name at the time of output. It was to be.
Your job is to write a program that converts the dates stored in the JAG database to dates using the Heisei or new era. Since the new era has not been announced yet, we will use "?" To represent it.
Input
The input consists of multiple datasets. Each dataset is represented in the following format.
> g y m d
g is a character string representing the era name, and g = HEISEI holds. y, m, and d are integers that represent the year, month, and day, respectively. 1 β€ y β€ 100, 1 β€ m β€ 12, 1 β€ d β€ 31 holds.
Dates that do not exist in the Japanese calendar, such as February 30, are not given as a dataset. When converted correctly as the Japanese calendar, the date on which the era before Heisei must be used is not given as a data set.
The end of the input is represented by a line consisting of only one'#'. The number of datasets does not exceed 100.
Output
For each data set, separate the converted era, year, month, and day with a space and output it on one line. If the converted era is "Heisei", use "HEISEI" as the era, and if it is a new era, use "?".
Normally, the first year of the era is written as the first year, but in the output of this problem, ignore this rule and output 1 as the year.
Sample Input
HEISEI 1 1 8
HEISEI 31 4 30
HEISEI 31 5 1
HEISEI 99 12 31
HEISEI 38 8 30
HEISEI 98 2 22
HEISEI 2 3 26
HEISEI 28 4 23
Output for the Sample Input
HEISEI 1 1 8
HEISEI 31 4 30
? 1 5 1
? 69 12 31
? 8 8 30
? 68 2 22
HEISEI 2 3 26
HEISEI 28 4 23
Example
Input
HEISEI 1 1 8
HEISEI 31 4 30
HEISEI 31 5 1
HEISEI 99 12 31
HEISEI 38 8 30
HEISEI 98 2 22
HEISEI 2 3 26
HEISEI 28 4 23
#
Output
HEISEI 1 1 8
HEISEI 31 4 30
? 1 5 1
? 69 12 31
? 8 8 30
? 68 2 22
HEISEI 2 3 26
HEISEI 28 4 23
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
while(true){
string g;
int y, m, d;
cin>>g;
if(g == "#") break;
cin>>y>>m>>d;
if(y<=30) cout<<g<<" "<<y<<" "<<m<<" "<<d<<endl;
else if(y == 31)cout<<(m<=4?g:"?")<<" "<<(m<=4?y:y-30)<<" "<<m<<" "<<d<<endl;
else cout<<"? "<<y-30<<" "<<m<<" "<<d<<endl;
}
return 0;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
Takahashi went to an all-you-can-eat buffet with N kinds of dishes and ate all of them (Dish 1, Dish 2, \ldots, Dish N) once.
The i-th dish (1 \leq i \leq N) he ate was Dish A_i.
When he eats Dish i (1 \leq i \leq N), he gains B_i satisfaction points.
Additionally, when he eats Dish i+1 just after eating Dish i (1 \leq i \leq N - 1), he gains C_i more satisfaction points.
Find the sum of the satisfaction points he gained.
Constraints
* All values in input are integers.
* 2 \leq N \leq 20
* 1 \leq A_i \leq N
* A_1, A_2, ..., A_N are all different.
* 1 \leq B_i \leq 50
* 1 \leq C_i \leq 50
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
B_1 B_2 ... B_N
C_1 C_2 ... C_{N-1}
Output
Print the sum of the satisfaction points Takahashi gained, as an integer.
Examples
Input
3
3 1 2
2 5 4
3 6
Output
14
Input
4
2 3 4 1
13 5 8 24
45 9 15
Output
74
Input
2
1 2
50 50
50
Output
150
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main()
{
int n,i,j;
cin>>n;
int a[n+1],b[n+1],c[n];
for(i=1;i<n+1;i++)
cin>>a[i];
for(i=1;i<n+1;i++)
cin>>b[i];
for(i=1;i<n;i++)
cin>>c[i];
int ans=0;
for(i=1;i<n+1;i++)
{
j=a[i];
ans+=b[j];
if(i-1>=0 && a[i-1]+1==a[i])
ans+=c[j-1];
}
cout<<ans;
return 0;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
I am a pipe tie craftsman. As long as you get the joints and pipes that connect the pipes, you can connect any pipe. Every day, my master gives me pipes and joints, which I connect and give to my master. But if you have too many pipes, you can't connect them all in one day. Even in such a case, the master smiles and gives me a salary.
By the way, I noticed something strange at one point. Often, the salary is higher when all the pipes are not connected than when they are all connected. It's so weird that one day when my boss came, I secretly saw a memo that describes how to calculate my salary. Then, how
"The salary is paid by" the number of pipes x the total length of pipes ". However, if they are connected by a joint and become one, it is regarded as one pipe. "
It was written. Now I understand why the salary may be cheaper if you connect them all. For example, as shown in the figure below, if you connect all three pipes of length 1 and two joints of length 2 to make one pipe of length 1 + 2 + 1 + 2 + 1 = 7, 1 Γ (7) ) = 7. However, if you use only one joint and make two pipes with a length of 1 + 2 + 1 = 4 and a pipe with a length of 1, 2 Γ (4 + 1) = 10, so you will get more salary than connecting all of them. ..
<image>
I don't know why my boss decides my salary this way, but I know how I can get more salary!
Now, create a program that calculates the maximum amount of salary you can get given the number of pipes.
input
The input consists of multiple datasets. The end of the input is indicated by a single zero line. Each dataset is given in the following format.
n
p1 ... pn
j1 ... jn-1
The number of pipes n (2 β€ n β€ 65000) is given in the first line. The second line consists of n integers separated by a single space. pi (1 β€ pi β€ 1000) indicates the length of the i-th pipe. The third line consists of n-1 integers separated by one space. ji (1 β€ ji β€ 1000) indicates the length of the i-th joint.
The i-th joint can connect only the i-th and i + 1-th pipes. The length of the connected pipe is pi + ji + pi + 1.
The number of datasets does not exceed 100.
output
For each dataset, print the maximum amount of salary you can get on one line. For datasets given as input, the output value must always fall within the range of 32-bit unsigned integers.
Example
Input
3
1 1 1
3 3
4
3 3 3 3
1 1 1
5
1 2 3 4 5
4 3 2 1
0
Output
12
48
76
### Response
```cpp
#include<stdio.h>
#include<algorithm>
#include<functional>
using namespace std;
int main(void)
{
int n,i,p,j[65000];
unsigned int a,b,c,x;
while(1){
a=0;
scanf("%d",&n);
if(n==0) break;
for(i=0;i<n;i++){
scanf("%d",&p); a+=p;
}
for(i=0;i<n-1;i++) scanf("%d",&j[i]);
sort(j,j+n-1,greater<int>());
x=n*a; b=a;
for(i=0;i<n-1;i++){
b+=j[i];
c=(n-(i+1))*b;
if(c>x) x=c;
}
printf("%u\n",x);
}
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
You have 4 bags A, B, C and D each of which includes N coins (there are totally 4N coins). Values of the coins in each bag are ai, bi, ci and di respectively.
Find the number of combinations that result when you choose one coin from each bag (totally 4 coins) in such a way that the total value of the coins is V. You should distinguish the coins in a bag.
Constraints
* 1 β€ N β€ 1000
* 1 β€ ai, bi, ci, di β€ 1016
* 1 β€ V β€ 1016
* All input values are given in integers
Input
The input is given in the following format.
N V
a1 a2 ... aN
b1 b2 ... bN
c1 c2 ... cN
d1 d2 ... dN
Output
Print the number of combinations in a line.
Examples
Input
3 14
3 1 2
4 8 2
1 2 3
7 3 2
Output
9
Input
5 4
1 1 1 1 1
1 1 1 1 1
1 1 1 1 1
1 1 1 1 1
Output
625
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef vector<ll> vl;
typedef pair<ll, ll> PP;
#define rep(i, n) for (ll i = 0; i < ll(n); i++)
#define all(v) v.begin(), v.end()
bool chmin(ll& a, ll b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
bool chmax(ll& a, ll b) {
if (b > a) {
a = b;
return 1;
}
return 0;
}
const ll INF = 999999999999999;
const ll MOD = 1000000007;
const ll MAX_N = 500010;
ll a, b, c, d, e, f, p, t, x, y, z, q, m, n, r, h, k, w, l, ans, s;
int main() {
cin >> n >> m;
vl A, B, C, D, X, Y;
rep(i, n) {
cin >> x;
A.push_back(x);
}
rep(i, n) {
cin >> x;
B.push_back(x);
}
rep(i, n) {
cin >> x;
C.push_back(x);
}
rep(i, n) {
cin >> x;
D.push_back(x);
}
rep(i, n) {
rep(j, n) {
X.push_back(A[i] + B[j]);
Y.push_back(C[i] + D[j]);
}
}
sort(all(X));
sort(all(Y));
rep(i,X.size()){
ans += upper_bound(all(Y), m - X[i]) - lower_bound(all(Y), m - X[i]);
}
cout << ans << endl;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
Edo has got a collection of n refrigerator magnets!
He decided to buy a refrigerator and hang the magnets on the door. The shop can make the refrigerator with any size of the door that meets the following restrictions: the refrigerator door must be rectangle, and both the length and the width of the door must be positive integers.
Edo figured out how he wants to place the magnets on the refrigerator. He introduced a system of coordinates on the plane, where each magnet is represented as a rectangle with sides parallel to the coordinate axes.
Now he wants to remove no more than k magnets (he may choose to keep all of them) and attach all remaining magnets to the refrigerator door, and the area of ββthe door should be as small as possible. A magnet is considered to be attached to the refrigerator door if its center lies on the door or on its boundary. The relative positions of all the remaining magnets must correspond to the plan.
Let us explain the last two sentences. Let's suppose we want to hang two magnets on the refrigerator. If the magnet in the plan has coordinates of the lower left corner (x1, y1) and the upper right corner (x2, y2), then its center is located at (<image>, <image>) (may not be integers). By saying the relative position should correspond to the plan we mean that the only available operation is translation, i.e. the vector connecting the centers of two magnets in the original plan, must be equal to the vector connecting the centers of these two magnets on the refrigerator.
The sides of the refrigerator door must also be parallel to coordinate axes.
Input
The first line contains two integers n and k (1 β€ n β€ 100 000, 0 β€ k β€ min(10, n - 1)) β the number of magnets that Edo has and the maximum number of magnets Edo may not place on the refrigerator.
Next n lines describe the initial plan of placing magnets. Each line contains four integers x1, y1, x2, y2 (1 β€ x1 < x2 β€ 109, 1 β€ y1 < y2 β€ 109) β the coordinates of the lower left and upper right corners of the current magnet. The magnets can partially overlap or even fully coincide.
Output
Print a single integer β the minimum area of the door of refrigerator, which can be used to place at least n - k magnets, preserving the relative positions.
Examples
Input
3 1
1 1 2 2
2 2 3 3
3 3 4 4
Output
1
Input
4 1
1 1 2 2
1 9 2 10
9 9 10 10
9 1 10 2
Output
64
Input
3 0
1 1 2 2
1 1 1000000000 1000000000
1 3 8 12
Output
249999999000000001
Note
In the first test sample it is optimal to remove either the first or the third magnet. If we remove the first magnet, the centers of two others will lie at points (2.5, 2.5) and (3.5, 3.5). Thus, it is enough to buy a fridge with door width 1 and door height 1, the area of the door also equals one, correspondingly.
In the second test sample it doesn't matter which magnet to remove, the answer will not change β we need a fridge with door width 8 and door height 8.
In the third sample you cannot remove anything as k = 0.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, k, x, y, del[100005];
int stax[15], stay[15], staX[15], staY[15];
long long ans = 1e18;
struct data {
int x, y, id;
} a[100005], b[100005], c[100005], d[100005];
bool cmpx(data a, data b) { return a.x < b.x; }
bool cmpy(data a, data b) { return a.y < b.y; }
bool cmpX(data a, data b) { return a.x > b.x; }
bool cmpY(data a, data b) { return a.y > b.y; }
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d%d%d%d", &a[i].x, &a[i].y, &x, &y);
a[i].x += x;
a[i].y += y;
a[i].id = i;
d[i] = c[i] = b[i] = a[i];
}
sort(a + 1, a + n + 1, cmpx);
sort(b + 1, b + n + 1, cmpy);
sort(c + 1, c + n + 1, cmpX);
sort(d + 1, d + n + 1, cmpY);
for (int totx = 0, lax = 1; totx <= k; totx++) {
for (int toty = 0, lay = 1; totx + toty <= k; toty++) {
for (int totX = 0, laX = 1; totx + toty + totX <= k; totX++) {
int totY = 0;
for (int i = 1; i <= n && totx + toty + totX + totY < k; i++)
if (!del[d[i].id]) {
del[d[i].id] = 1;
staY[++totY] = d[i].id;
}
int x = 1, y = 1, X = 1, Y = 1;
for (; del[a[x].id]; x++)
;
for (; del[b[y].id]; y++)
;
for (; del[c[X].id]; X++)
;
for (; del[d[Y].id]; Y++)
;
ans = min(ans, 1ll * max(1, (c[X].x - a[x].x + 1) / 2) *
max((d[Y].y - b[y].y + 1) / 2, 1));
for (; totY; totY--) del[staY[totY]] = 0;
if (totx + toty + totX == k) {
for (; totX; totX--) del[staX[totX]] = 0;
break;
}
for (; laX <= n && del[c[laX].id];) laX++;
if (laX > n) {
for (; totX; totX--) del[staX[totX]] = 0;
break;
}
del[c[laX].id] = 1;
staX[totX + 1] = c[laX].id;
}
if (totx + toty == k) {
for (; toty; toty--) del[stay[toty]] = 0;
break;
}
for (; lay <= n && del[b[lay].id];) lay++;
if (lay > n) {
for (; toty; toty--) del[stay[toty]] = 0;
break;
}
del[b[lay].id] = 1;
stay[toty + 1] = b[lay].id;
}
for (; lax <= n && del[a[lax].id];) lax++;
if (lax > n) break;
del[a[lax].id] = 1;
}
printf("%lld\n", ans);
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
Kolya loves putting gnomes at the circle table and giving them coins, and Tanya loves studying triplets of gnomes, sitting in the vertexes of an equilateral triangle.
More formally, there are 3n gnomes sitting in a circle. Each gnome can have from 1 to 3 coins. Let's number the places in the order they occur in the circle by numbers from 0 to 3n - 1, let the gnome sitting on the i-th place have ai coins. If there is an integer i (0 β€ i < n) such that ai + ai + n + ai + 2n β 6, then Tanya is satisfied.
Count the number of ways to choose ai so that Tanya is satisfied. As there can be many ways of distributing coins, print the remainder of this number modulo 109 + 7. Two ways, a and b, are considered distinct if there is index i (0 β€ i < 3n), such that ai β bi (that is, some gnome got different number of coins in these two ways).
Input
A single line contains number n (1 β€ n β€ 105) β the number of the gnomes divided by three.
Output
Print a single number β the remainder of the number of variants of distributing coins that satisfy Tanya modulo 109 + 7.
Examples
Input
1
Output
20
Input
2
Output
680
Note
20 ways for n = 1 (gnome with index 0 sits on the top of the triangle, gnome 1 on the right vertex, gnome 2 on the left vertex): <image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long mod = (long long)(1e9 + 7);
const int MAX_N = 100010;
long long dp[MAX_N] = {0, 20};
void init() {
long long tmp = 1;
for (int i = 2; i < MAX_N; i++) {
tmp = tmp * 27 % mod;
dp[i] = (tmp * 20 % mod + 7 * dp[i - 1]) % mod;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
init();
while (~scanf("%d", &n)) {
printf("%I64d\n", dp[n]);
}
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
One company of IT City decided to create a group of innovative developments consisting from 5 to 7 people and hire new employees for it. After placing an advertisment the company received n resumes. Now the HR department has to evaluate each possible group composition and select one of them. Your task is to count the number of variants of group composition to evaluate.
Input
The only line of the input contains one integer n (7 β€ n β€ 777) β the number of potential employees that sent resumes.
Output
Output one integer β the number of different variants of group composition.
Examples
Input
7
Output
29
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<int> p;
bool is_prime(int n) {
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) {
return false;
}
}
return true;
}
unsigned long long get(int n, int k) {
vector<int> cnt((int)(p).size(), 0);
for (int i = 2; i <= n; i++) {
int x = i;
for (int j = 0; j < (int)(p).size(); j++) {
while (x % p[j] == 0) {
x /= p[j];
cnt[j]++;
}
}
}
for (int i = 2; i <= k; i++) {
int x = i;
for (int j = 0; j < (int)(p).size(); j++) {
while (x % p[j] == 0) {
x /= p[j];
cnt[j]--;
}
}
}
for (int i = 2; i <= n - k; i++) {
int x = i;
for (int j = 0; j < (int)(p).size(); j++) {
while (x % p[j] == 0) {
x /= p[j];
cnt[j]--;
}
}
}
unsigned long long res = 1;
for (int i = 0; i < (int)(p).size(); i++) {
for (int j = 1; j <= cnt[i]; j++) {
res *= p[i];
}
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
for (int i = 2; i <= 1000; i++) {
if (is_prime(i)) {
p.push_back(i);
}
}
int n;
cin >> n;
unsigned long long res = 0;
for (int k = 5; k <= 7; k++) {
res += get(n, k);
}
cout << res << "\n";
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
You work as a system administrator in a dormitory, which has n rooms one after another along a straight hallway. Rooms are numbered from 1 to n.
You have to connect all n rooms to the Internet.
You can connect each room to the Internet directly, the cost of such connection for the i-th room is i coins.
Some rooms also have a spot for a router. The cost of placing a router in the i-th room is also i coins. You cannot place a router in a room which does not have a spot for it. When you place a router in the room i, you connect all rooms with the numbers from max(1,~i - k) to min(n,~i + k) inclusive to the Internet, where k is the range of router. The value of k is the same for all routers.
Calculate the minimum total cost of connecting all n rooms to the Internet. You can assume that the number of rooms which have a spot for a router is not greater than the number of routers you have.
Input
The first line of the input contains two integers n and k (1 β€ n, k β€ 2 β
10^5) β the number of rooms and the range of each router.
The second line of the input contains one string s of length n, consisting only of zeros and ones. If the i-th character of the string equals to '1' then there is a spot for a router in the i-th room. If the i-th character of the string equals to '0' then you cannot place a router in the i-th room.
Output
Print one integer β the minimum total cost of connecting all n rooms to the Internet.
Examples
Input
5 2
00100
Output
3
Input
6 1
000000
Output
21
Input
4 1
0011
Output
4
Input
12 6
000010000100
Output
15
Note
In the first example it is enough to place the router in the room 3, then all rooms will be connected to the Internet. The total cost of connection is 3.
In the second example you can place routers nowhere, so you need to connect all rooms directly. Thus, the total cost of connection of all rooms is 1 + 2 + 3 + 4 + 5 + 6 = 21.
In the third example you need to connect the room 1 directly and place the router in the room 3. Thus, the total cost of connection of all rooms is 1 + 3 = 4.
In the fourth example you need to place routers in rooms 5 and 10. Then all rooms will be connected to the Internet. The total cost of connection is 5 + 10 = 15.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 5;
const long long inf = 1e11;
const long long mod = 1e9 + 7;
class segment_Tree_min {
class node {
public:
int l, r;
long long lazy;
long long min;
};
void pushdown(int root) {
if (tree[root].lazy) {
tree[root << 1].min = tree[root].lazy;
tree[root << 1 | 1].min = tree[root].lazy;
tree[root << 1].lazy = tree[root].lazy;
tree[root << 1 | 1].lazy = tree[root].lazy;
tree[root].lazy = 0;
}
}
void pushup(int root) {
tree[root].min = min(tree[root << 1].min, tree[root << 1 | 1].min);
}
int n;
vector<node> tree;
public:
vector<long long> array;
segment_Tree_min(int _n) : n(_n), tree((_n + 1) << 2), array(_n + 1){};
void build(int l, int r, int root = 1) {
tree[root].l = l;
tree[root].r = r;
tree[root].lazy = 0;
if (l == r) {
tree[root].min = inf;
return;
}
int mid = (l + r) >> 1;
build(l, mid, root << 1);
build(mid + 1, r, root << 1 | 1);
pushup(root);
}
void updata(int l, int r, long long val, int root = 1) {
if (l <= tree[root].l && r >= tree[root].r) {
tree[root].min = val;
tree[root].lazy = val;
return;
}
pushdown(root);
int mid = (tree[root].l + tree[root].r) >> 1;
if (l <= mid) updata(l, r, val, root << 1);
if (r > mid) updata(l, r, val, root << 1 | 1);
pushup(root);
}
long long query(int l, int r, int root = 1) {
if (l <= tree[root].l && r >= tree[root].r) {
return tree[root].min;
}
pushdown(root);
int mid = (tree[root].l + tree[root].r) >> 1;
long long Min = inf;
if (l <= mid) {
Min = min(query(l, r, root << 1), Min);
}
if (r > mid) {
Min = min(query(l, r, root << 1 | 1), Min);
}
return Min;
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int n, k;
cin >> n >> k;
string s;
cin >> s;
segment_Tree_min T(n), T1(n);
T.build(1, n);
T1.build(1, n);
vector<vector<long long>> dp(n + 1, vector<long long>(2, inf));
dp[0][0] = 0;
for (int i = 1; i <= n; ++i) {
dp[i][0] = min(dp[i - 1][0] + i, T1.query(max(1, i - k), i - 1));
if (s[i - 1] == '1') {
if (i - k - 1 <= 0) {
dp[i][1] = 0;
} else {
dp[i][1] = min(T.query(i - k - 1, i - 1), T1.query(i - k - 1, i - 1));
}
dp[i][1] += i;
}
T.updata(i, i, dp[i][0]);
T1.updata(i, i, dp[i][1]);
}
cout << min(dp[n][0], dp[n][1]) << endl;
return 0;
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
You have a new professor of graph theory and he speaks very quickly. You come up with the following plan to keep up with his lecture and make notes.
You know two languages, and the professor is giving the lecture in the first one. The words in both languages consist of lowercase English characters, each language consists of several words. For each language, all words are distinct, i.e. they are spelled differently. Moreover, the words of these languages have a one-to-one correspondence, that is, for each word in each language, there exists exactly one word in the other language having has the same meaning.
You can write down every word the professor says in either the first language or the second language. Of course, during the lecture you write down each word in the language in which the word is shorter. In case of equal lengths of the corresponding words you prefer the word of the first language.
You are given the text of the lecture the professor is going to read. Find out how the lecture will be recorded in your notes.
Input
The first line contains two integers, n and m (1 β€ n β€ 3000, 1 β€ m β€ 3000) β the number of words in the professor's lecture and the number of words in each of these languages.
The following m lines contain the words. The i-th line contains two strings ai, bi meaning that the word ai belongs to the first language, the word bi belongs to the second language, and these two words have the same meaning. It is guaranteed that no word occurs in both languages, and each word occurs in its language exactly once.
The next line contains n space-separated strings c1, c2, ..., cn β the text of the lecture. It is guaranteed that each of the strings ci belongs to the set of strings {a1, a2, ... am}.
All the strings in the input are non-empty, each consisting of no more than 10 lowercase English letters.
Output
Output exactly n words: how you will record the lecture in your notebook. Output the words of the lecture in the same order as in the input.
Examples
Input
4 3
codeforces codesecrof
contest round
letter message
codeforces contest letter contest
Output
codeforces round letter round
Input
5 3
joll wuqrd
euzf un
hbnyiyc rsoqqveh
hbnyiyc joll joll euzf joll
Output
hbnyiyc joll joll un joll
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
int main() {
long long tcase, i, j;
tcase = 1;
while (tcase--) {
int n, m;
cin >> n >> m;
map<string, string> M;
string a, b, cs;
for (int i = 0; i < m; i++) {
cin >> a >> b;
if (M.find(a) == M.end()) {
if (a.length() == b.length()) {
M[a] = a;
M[b] = a;
} else if (a.length() > b.length()) {
M[a] = b;
M[b] = b;
} else {
M[a] = a;
M[b] = a;
}
}
}
string s;
vector<string> vs;
for (int i = 0; i < n; i++) {
cin >> s;
vs.push_back(M[s]);
}
for (auto u : vs) cout << u << " ";
}
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
There are N one-off jobs available. If you take the i-th job and complete it, you will earn the reward of B_i after A_i days from the day you do it.
You can take and complete at most one of these jobs in a day.
However, you cannot retake a job that you have already done.
Find the maximum total reward that you can earn no later than M days from today.
You can already start working today.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^5
* 1 \leq M \leq 10^5
* 1 \leq A_i \leq 10^5
* 1 \leq B_i \leq 10^4
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
A_2 B_2
\vdots
A_N B_N
Output
Print the maximum total reward that you can earn no later than M days from today.
Examples
Input
3 4
4 3
4 1
2 2
Output
5
Input
5 3
1 2
1 3
1 4
2 1
2 3
Output
10
Input
1 1
2 1
Output
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using P=pair<int,int>;
int main(){
int n,m; cin>>n>>m;
vector<vector<int>> job(100001);
priority_queue<int> pq;
for(int i=0;i<n;i++){
int a,b; cin>>a>>b;
job[a].push_back(b);
}
long long ans=0;
for(int i=1;i<=m;i++){
for(int j=0;j<job[i].size();j++){
pq.push(job[i][j]);
}
if(!pq.empty()){
ans+=pq.top(); pq.pop();
}
}
cout<<ans<<endl;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
Watchmen are in a danger and Doctor Manhattan together with his friend Daniel Dreiberg should warn them as soon as possible. There are n watchmen on a plane, the i-th watchman is located at point (xi, yi).
They need to arrange a plan, but there are some difficulties on their way. As you know, Doctor Manhattan considers the distance between watchmen i and j to be |xi - xj| + |yi - yj|. Daniel, as an ordinary person, calculates the distance using the formula <image>.
The success of the operation relies on the number of pairs (i, j) (1 β€ i < j β€ n), such that the distance between watchman i and watchmen j calculated by Doctor Manhattan is equal to the distance between them calculated by Daniel. You were asked to compute the number of such pairs.
Input
The first line of the input contains the single integer n (1 β€ n β€ 200 000) β the number of watchmen.
Each of the following n lines contains two integers xi and yi (|xi|, |yi| β€ 109).
Some positions may coincide.
Output
Print the number of pairs of watchmen such that the distance between them calculated by Doctor Manhattan is equal to the distance calculated by Daniel.
Examples
Input
3
1 1
7 5
1 5
Output
2
Input
6
0 0
0 1
0 2
-1 1
0 1
1 1
Output
11
Note
In the first sample, the distance between watchman 1 and watchman 2 is equal to |1 - 7| + |1 - 5| = 10 for Doctor Manhattan and <image> for Daniel. For pairs (1, 1), (1, 5) and (7, 5), (1, 5) Doctor Manhattan and Daniel will calculate the same distances.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
long long int ans = 0;
map<long long int, long long int> map1, map2;
map<pair<long long int, long long int>, long long int> map3;
for (long long int i = 0; i < n; i++) {
long long int a, b;
cin >> a >> b;
ans += map1[a];
ans += map2[b];
ans -= map3[{a, b}];
map1[a]++;
map2[b]++;
map3[{a, b}]++;
}
cout << ans << endl;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
problem
JOI Pizza sells pizza home delivery along the d-meter-long ring road that runs through the city center.
JOI Pizza has n stores S1, ..., Sn on the loop line. The head office is S1. The distance from S1 to Si when moving the loop line clockwise is set to di meters. D2 , ..., dn is an integer greater than or equal to 1 and less than or equal to d -1. D2, ..., dn are all different. Bake and deliver pizza at the shortest store.
The location of the delivery destination is represented by an integer k that is greater than or equal to 0 and less than or equal to d -1. This means that the distance from the head office S1 to the delivery destination in the clockwise direction is k meters. Pizza delivery is done along the loop line and no other road is allowed. However, the loop line may move clockwise or counterclockwise.
For example, if the location of the store and the location of the delivery destination are as shown in the figure below (this example corresponds to Example 1 of "I / O example").
<image>
The store closest to the delivery destination 1 is S2, so the delivery is from store S2. At this time, the distance traveled from the store is 1. Also, the store closest to delivery destination 2 is S1 (main store), so store S1 (main store). ) To deliver to home. At this time, the distance traveled from the store is 2.
Total length of the loop line d, Number of JOI pizza stores n, Number of orders m, N --1 integer representing a location other than the main store d2, ..., dn, Integer k1, .. representing the location of the delivery destination Given ., km, create a program to find the sum of all orders for each order by the distance traveled during delivery (ie, the distance from the nearest store to the delivery destination).
input
The input consists of multiple datasets. Each dataset is given in the following format.
The first line is a positive integer d (2 β€ d β€ 1000000000 = 109) that represents the total length of the loop line, the second line is a positive integer n (2 β€ n β€ 100000) that represents the number of stores, and the third line is A positive integer m (1 β€ m β€ 10000) is written to represent the number of orders. The n --1 lines after the 4th line are integers d2, d3, ..., dn that represent the location of stores other than the main store. (1 β€ di β€ d -1) is written in this order, and the integers k1, k2, ..., km (0 β€ ki β€ d) representing the delivery destination location are in the m lines after the n + 3rd line. --1) are written in this order.
Of the scoring data, for 40% of the points, n β€ 10000 is satisfied. For 40% of the points, the total distance traveled and the value of d are both 1000000 or less. In the scoring data, the total distance traveled is 1000000000 = 109 or less.
When d is 0, it indicates the end of input. The number of data sets does not exceed 10.
output
For each data set, one integer representing the total distance traveled during delivery is output on one line.
Examples
Input
8
3
2
3
1
4
6
20
4
4
12
8
16
7
7
11
8
0
Output
3
3
Input
None
Output
None
### Response
```cpp
#include <cstdlib>
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main(void){
int d;
int n,m;
int a,b;
long long int ans=0;
while(1){
cin >> d;
if(d==0)break;
ans=0;
vector<int> data;
data.push_back(0);
cin >> n;
cin >> m;
for(a=0;a<n-1;a++){
scanf("%d",&b);
data.push_back(b);
}
data.push_back(d);
sort(data.begin(),data.end());
for(a=0;a<m;a++){
cin >> b;
int w=abs(b-*(lower_bound(data.begin(),data.end(),b)-1));
w=min(w,abs(b-*lower_bound(data.begin(),data.end(),b)));
ans+=w;
}
cout << ans << endl;
}
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
The developers of Looksery have to write an efficient algorithm that detects faces on a picture. Unfortunately, they are currently busy preparing a contest for you, so you will have to do it for them.
In this problem an image is a rectangular table that consists of lowercase Latin letters. A face on the image is a 2 Γ 2 square, such that from the four letters of this square you can make word "face".
You need to write a program that determines the number of faces on the image. The squares that correspond to the faces can overlap.
Input
The first line contains two space-separated integers, n and m (1 β€ n, m β€ 50) β the height and the width of the image, respectively.
Next n lines define the image. Each line contains m lowercase Latin letters.
Output
In the single line print the number of faces on the image.
Examples
Input
4 4
xxxx
xfax
xcex
xxxx
Output
1
Input
4 2
xx
cf
ae
xx
Output
1
Input
2 3
fac
cef
Output
2
Input
1 4
face
Output
0
Note
In the first sample the image contains a single face, located in a square with the upper left corner at the second line and the second column:
<image>
In the second sample the image also contains exactly one face, its upper left corner is at the second row and the first column.
In the third sample two faces are shown:
<image>
In the fourth sample the image has no faces on it.
### Response
```cpp
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
char s[55][55];
int main() {
int T, i, j, k, n, m;
scanf("%d%d", &n, &m);
for (i = 0; i < n; i++) scanf("%s", s[i]);
int ans = 0;
for (i = 0; i < n - 1; i++)
for (j = 0; j < m - 1; j++) {
int v[4] = {0};
for (int l = 0; l < 2; l++)
for (int r = 0; r < 2; r++) {
if (s[i + l][j + r] == 'f') v[0]++;
if (s[i + l][j + r] == 'a') v[1]++;
if (s[i + l][j + r] == 'c') v[2]++;
if (s[i + l][j + r] == 'e') v[3]++;
}
if (v[0] && v[1] && v[2] && v[3]) ans++;
}
printf("%d\n", ans);
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
Vasya has started watching football games. He has learned that for some fouls the players receive yellow cards, and for some fouls they receive red cards. A player who receives the second yellow card automatically receives a red card.
Vasya is watching a recorded football match now and makes notes of all the fouls that he would give a card for. Help Vasya determine all the moments in time when players would be given red cards if Vasya were the judge. For each player, Vasya wants to know only the first moment of time when he would receive a red card from Vasya.
Input
The first line contains the name of the team playing at home. The second line contains the name of the team playing away. Both lines are not empty. The lengths of both lines do not exceed 20. Each line contains only of large English letters. The names of the teams are distinct.
Next follows number n (1 β€ n β€ 90) β the number of fouls.
Each of the following n lines contains information about a foul in the following form:
* first goes number t (1 β€ t β€ 90) β the minute when the foul occurs;
* then goes letter "h" or letter "a" β if the letter is "h", then the card was given to a home team player, otherwise the card was given to an away team player;
* then goes the player's number m (1 β€ m β€ 99);
* then goes letter "y" or letter "r" β if the letter is "y", that means that the yellow card was given, otherwise the red card was given.
The players from different teams can have the same number. The players within one team have distinct numbers. The fouls go chronologically, no two fouls happened at the same minute.
Output
For each event when a player received his first red card in a chronological order print a string containing the following information:
* The name of the team to which the player belongs;
* the player's number in his team;
* the minute when he received the card.
If no player received a card, then you do not need to print anything.
It is possible case that the program will not print anything to the output (if there were no red cards).
Examples
Input
MC
CSKA
9
28 a 3 y
62 h 25 y
66 h 42 y
70 h 25 y
77 a 4 y
79 a 25 y
82 h 42 r
89 h 16 y
90 a 13 r
Output
MC 25 70
MC 42 82
CSKA 13 90
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 105;
string n[2];
int r[2][MAXN], f[2][MAXN], m, t, p;
char pt, ct;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n[0] >> n[1] >> m;
for (int i = 0; i < m; ++i) {
cin >> t >> pt >> p >> ct;
int idx = pt == 'h' ? 0 : 1;
f[idx][p] += ct == 'y' ? 1 : 2;
if (r[idx][p] == 0 && f[idx][p] > 1) {
r[idx][p] = 1;
cout << n[idx] << " " << p << " " << t << endl;
}
}
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;
int n, m;
double mx[100005], mn[100005], sum1[100005], sum2[100005];
inline int read() {
int x = 0, f = 1;
char ch = getchar();
for (; ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') f = -1;
for (; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0';
return x * f;
}
inline void print(int x) {
if (x >= 10) print(x / 10);
putchar(x % 10 + '0');
}
int main() {
n = read();
for (int i = 1; i <= n; i++) scanf("%lf", &mx[i]), mx[i] += mx[i - 1];
for (int i = 1; i <= n; i++) scanf("%lf", &mn[i]);
for (int i = n - 1; i; i--) mn[i] += mn[i + 1];
for (int i = 1; i <= n; i++) {
double x = 1 + mx[i] - mn[i + 1], y = sqrt(max(x * x - 4 * mx[i], 0.0));
sum1[i] = (x + y) * 0.5, sum2[i] = (x - y) * 0.5;
}
for (int i = n; i; i--) sum1[i] -= sum1[i - 1], sum2[i] -= sum2[i - 1];
for (int i = 1; i <= n; i++) printf("%lf ", sum1[i]);
puts("");
for (int i = 1; i <= n; i++) printf("%lf ", sum2[i]);
puts("");
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
problem
You are in charge of quality control at a machine manufacturing plant. This machine requires a power supply, a motor, and a cable as parts. The manufacturing plant has a power supply, b motors, and c cables, numbered from 1 to a, a + 1 to a + b, and a + b + 1 to a + b + c, respectively. attached. The trouble is that some parts may be out of order. I want to know which parts are out of order and which parts are normal in the factory.
Therefore, the factory inspected the parts by the following method. Bring the power supply, motor, and cable one by one, connect them, and try to operate them. At this time, if all three parts are normal, it operates correctly and is recognized as "passed". If any of the three parts is out of order, it will not operate properly and will be recognized as "failed". (Since the machines made in the factory are so precise, it does not happen that the broken parts are mixed and operate correctly by accident.)
You will be given a list of test results. Each line in the list of test results shows the numbers of the power supply, motor, and cable used for the test, and whether the test passed or failed.
Given a list of inspection results, all parts are either faulty or normal from the inspection results, some are definitely faulty, some are definitely normal. Create a program to classify parts that are not decided.
input
The input consists of multiple datasets. The format of each data set is as follows. The input ends on a line containing three zeros.
Three integers are written on the first line, separated by blanks, and represent the number of power supplies a, the number of motors b, and the number of cables c in order.
One integer is written on the second line, and the number of tests N included in the list of test results is written.
The next N lines represent a list of test results. On each line, four integers i, j, k, r are written with one blank as a delimiter, and the result of inspection by connecting the power supply i, the motor j, and the cable k is "pass" (r = 1). (When) or "Fail" (when r = 0).
a, b, c, N satisfy 1 β€ a, b, c β€ 100, 1 β€ N β€ 1000.
The number of datasets does not exceed 5.
output
Output in the following format for each data set. The output of each dataset consists of lines a + b + c.
Line i (1 β€ i β€ a + b + c):
* If the inspection result shows that the part i is out of order, 0 is output.
* If the inspection result shows that the part i is normal, 1 is output.
* Output 2 if the inspection result does not determine whether part i is defective or normal.
Examples
Input
2 2 2
4
2 4 5 0
2 3 6 0
1 4 5 0
2 3 5 1
0 0 0
Output
2
1
1
0
1
0
Input
None
Output
None
### Response
```cpp
#include <iostream>
#include <algorithm>
#include <cassert>
#include <cctype>
#include <cstdio>
#include <math.h>
#include <map>
#include <queue>
#include <string>
#include <vector>
using namespace std;
int a,b,c,N,d,e,f,r,p[301];
struct test{int x,y,z,w;};
test t[1000];
int main(){
while(cin>>a>>b>>c){
if(a+b+c==0)return 0;
for(int i=1;i<=a+b+c;i++)p[i]=2;
cin>>N;
for(int i=0;i<N;i++){
cin>>d>>e>>f>>r;
t[i].x=d;t[i].y=e;t[i].z=f;t[i].w=r;
}
for(int i=0;i<N;i++)if(t[i].w==1){
p[t[i].x]=1;p[t[i].y]=1;p[t[i].z]=1;
}
for(int i=0;i<N;i++)if(t[i].w==0){
if(p[t[i].x]==1&&p[t[i].y]==1)p[t[i].z]=0;
if(p[t[i].y]==1&&p[t[i].z]==1)p[t[i].x]=0;
if(p[t[i].z]==1&&p[t[i].x]==1)p[t[i].y]=0;
}
for(int i=1;i<=a+b+c;i++)cout<<p[i]<<endl;
}
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
Little Artem found a grasshopper. He brought it to his house and constructed a jumping area for him.
The area looks like a strip of cells 1 Γ n. Each cell contains the direction for the next jump and the length of that jump. Grasshopper starts in the first cell and follows the instructions written on the cells. Grasshopper stops immediately if it jumps out of the strip. Now Artem wants to find out if this will ever happen.
Input
The first line of the input contains a single integer n (1 β€ n β€ 100 000) β length of the strip.
Next line contains a string of length n which consists of characters "<" and ">" only, that provide the direction of the jump from the corresponding cell. Next line contains n integers di (1 β€ di β€ 109) β the length of the jump from the i-th cell.
Output
Print "INFINITE" (without quotes) if grasshopper will continue his jumps forever. Otherwise print "FINITE" (without quotes).
Examples
Input
2
><
1 2
Output
FINITE
Input
3
>><
2 1 1
Output
INFINITE
Note
In the first sample grasshopper starts from the first cell and jumps to the right on the next cell. When he is in the second cell he needs to jump two cells left so he will jump out of the strip.
Second sample grasshopper path is 1 - 3 - 2 - 3 - 2 - 3 and so on. The path is infinite.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T sqr(const T& x) {
return x * x;
}
template <class T>
inline void updMin(T& a, const T& b) {
if (b < a) a = b;
}
template <class T>
inline void updMax(T& a, const T& b) {
if (b > a) a = b;
}
const int maxn = 200000;
int n;
char s[maxn];
int a[maxn];
int used[maxn];
int main() {
scanf("%d", &n);
scanf("%s", s);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
int p = 0;
while (p >= 0 && p < n && !used[p]) {
used[p] = 1;
p += a[p] * (s[p] == '>' ? 1 : -1);
}
if (p < 0 || p >= n) {
puts("FINITE");
} else {
puts("INFINITE");
}
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
Kuroni is very angry at the other setters for using him as a theme! As a punishment, he forced them to solve the following problem:
You have an array a consisting of n positive integers. An operation consists of choosing an element and either adding 1 to it or subtracting 1 from it, such that the element remains positive. We say the array is good if the greatest common divisor of all its elements is not 1. Find the minimum number of operations needed to make the array good.
Unable to match Kuroni's intellect, the setters failed to solve the problem. Help them escape from Kuroni's punishment!
Input
The first line contains an integer n (2 β€ n β€ 2 β
10^5) β the number of elements in the array.
The second line contains n integers a_1, a_2, ..., a_n. (1 β€ a_i β€ 10^{12}) β the elements of the array.
Output
Print a single integer β the minimum number of operations required to make the array good.
Examples
Input
3
6 2 4
Output
0
Input
5
9 8 7 3 1
Output
4
Note
In the first example, the first array is already good, since the greatest common divisor of all the elements is 2.
In the second example, we may apply the following operations:
1. Add 1 to the second element, making it equal to 9.
2. Subtract 1 from the third element, making it equal to 6.
3. Add 1 to the fifth element, making it equal to 2.
4. Add 1 to the fifth element again, making it equal to 3.
The greatest common divisor of all elements will then be equal to 3, so the array will be good. It can be shown that no sequence of three or less operations can make the array good.
### Response
```cpp
#include <bits/stdc++.h>
#pragma GCC optimize( \
"Ofast,no-stack-protector,unroll-loops,no-stack-protector,fast-math")
using namespace std;
const int N = 2e5 + 5, M = 1e6 + 5;
mt19937_64 mt(chrono::steady_clock::now().time_since_epoch().count());
bitset<M> vis;
void Sieve() {
vis.set();
vis[0] = vis[1] = false;
for (int i = 4; i < M; i += 2) vis[i] = false;
for (int i = 3; i < M / i; i += 2) {
if (!vis[i]) continue;
for (int j = i * i; j < M; j += i + i) vis[j] = false;
}
}
vector<long long> primes;
void Gen() {
for (int i = 2; i < M; ++i)
if (vis[i]) primes.emplace_back(i);
}
int n;
long long a[N];
long long solve(long long p) {
long long ret = 0;
for (int i = 0; i < n; ++i) {
if (a[i] < p) {
ret += (p - a[i]);
continue;
}
long long rem = a[i] % p;
ret += min(rem, p - rem);
}
return ret;
}
vector<long long> pr;
void fact(long long x) {
int idx = 0, sz = primes.size();
while (x > 1 && idx < sz && x >= primes[idx] * primes[idx]) {
while (x % primes[idx] == 0) x /= primes[idx], pr.emplace_back(primes[idx]);
++idx;
}
if (x > 1) pr.emplace_back(x);
}
int main() {
Sieve(), Gen();
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%lld", a + i);
shuffle(a, a + n, mt);
for (int i = 0; i < 7; ++i) fact(a[i]), fact(a[i] - 1), fact(a[i] + 1);
sort(pr.begin(), pr.end());
pr.resize(unique(pr.begin(), pr.end()) - pr.begin());
long long mn = n;
for (auto p : pr) mn = min(mn, solve(p));
printf("%lld\n", mn);
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
This is an interactive problem. Remember to flush your output while communicating with the testing program. You may use fflush(stdout) in C++, system.out.flush() in Java, stdout.flush() in Python or flush(output) in Pascal to flush the output. If you use some other programming language, consult its documentation. You may also refer to the guide on interactive problems: <https://codeforces.com/blog/entry/45307>.
There is a city in which Dixit lives. In the city, there are n houses. There is exactly one directed road between every pair of houses. For example, consider two houses A and B, then there is a directed road either from A to B or from B to A but not both. The number of roads leading to the i-th house is k_i.
Two houses A and B are bi-reachable if A is reachable from B and B is reachable from A. We say that house B is reachable from house A when there is a path from house A to house B.
Dixit wants to buy two houses in the city, that is, one for living and one for studying. Of course, he would like to travel from one house to another. So, he wants to find a pair of bi-reachable houses A and B. Among all such pairs, he wants to choose one with the maximum value of |k_A - k_B|, where k_i is the number of roads leading to the house i. If more than one optimal pair exists, any of them is suitable.
Since Dixit is busy preparing CodeCraft, can you help him find the desired pair of houses, or tell him that no such houses exist?
In the problem input, you are not given the direction of each road. You are given β for each house β only the number of incoming roads to that house (k_i).
You are allowed to ask only one type of query from the judge: give two houses A and B, and the judge answers whether B is reachable from A. There is no upper limit on the number of queries. But, you cannot ask more queries after the judge answers "Yes" to any of your queries. Also, you cannot ask the same query twice.
Once you have exhausted all your queries (or the judge responds "Yes" to any of your queries), your program must output its guess for the two houses and quit.
See the Interaction section below for more details.
Input
The first line contains a single integer n (3 β€ n β€ 500) denoting the number of houses in the city. The next line contains n space-separated integers k_1, k_2, ..., k_n (0 β€ k_i β€ n - 1), the i-th of them represents the number of incoming roads to the i-th house.
Interaction
To ask a query, print "? A B" (1 β€ A,B β€ N, Aβ B). The judge will respond "Yes" if house B is reachable from house A, or "No" otherwise.
To output the final answer, print "! A B", where A and B are bi-reachable with the maximum possible value of |k_A - k_B|. If there does not exist such pair of houses A and B, output "! 0 0".
After outputting the final answer, your program must terminate immediately, otherwise you will receive Wrong Answer verdict.
You cannot ask the same query twice. There is no upper limit to the number of queries you ask, but, you cannot ask more queries after the judge answers "Yes" to any of your queries. Your program must now output the final answer ("! A B" or "! 0 0") and terminate.
If you ask a query in incorrect format or repeat a previous query, you will get Wrong Answer verdict.
After printing a query do not forget to output the end of the line and flush the output. Otherwise, you will get the Idleness limit exceeded error. To do this, use:
* fflush(stdout) or cout.flush() in C++;
* System.out.flush() in Java;
* flush(output) in Pascal;
* stdout.flush() in Python;
* see documentation for other languages.
Examples
Input
3
1 1 1
Yes
Output
? 1 2
! 1 2
Input
4
1 2 0 3
No
No
No
No
No
No
Output
? 2 1
? 1 3
? 4 1
? 2 3
? 4 2
? 4 3
! 0 0
Note
In the first sample input, we are given a city of three houses with one incoming road each. The user program asks one query: "? 1 2": asking whether we can reach from house 1 to house 2. The judge responds with "Yes". The user program now concludes that this is sufficient information to determine the correct answer. So, it outputs "! 1 2" and quits.
In the second sample input, the user program queries for six different pairs of houses, and finally answers "! 0 0" as it is convinced that no two houses as desired in the question exist in this city.
### Response
```cpp
#pragma GCC optimize(2)
#include <bits/stdc++.h>
#include <memory>
using namespace std;
#define sf(a) scanf("%d",&a)
#define pf(a) printf("%d",a)
#define ford(i,a,n) for(i=a;i<=n;i++)
#define forb(i,n,a) for(i=n;i>=a;i--)
#define mst(a,b) memset(a,b,sizeof(a))
typedef long long ll;
typedef unsigned long long ull;
typedef double db;
#define pb push_back
#define ddd cout<<"ddd"<<endl
#define maxn 500010
#define inf 0x7fffffff
const ll mod=1e9+7;
struct point{
int x,y;
int res;
}k[maxn];
int cmp(point a,point b)
{
if(a.res==b.res)
{
if(a.x>b.x)
return a.y>b.y;
return a.x>b.x;
}
return a.res>b.res;
}
int a[maxn];
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
//ddd;
int n;
cin>>n;
int i,j;
int amount=0;
ford(i,1,n)
{
cin>>a[i];
}
ford(i,1,n)
ford(j,i+1,n)
{
k[++amount].x=i;
k[amount].y=j;
k[amount].res=abs(a[i]-a[j]);
if(a[i]<a[j])
swap(k[amount].x,k[amount].y);
}
sort(k+1,k+amount+1,cmp);
ford(i,1,amount)
{
cout<<"? "<<k[i].x<<" "<<k[i].y<<endl;
cout.flush();
string op;
cin>>op;
if(op=="Yes")
{
cout<<"! "<<k[i].x<<" "<<k[i].y;
return 0;
}
}
cout<<"! 0 0";
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
There is a chain consisting of multiple circles on a plane. The first (last) circle of the chain only intersects with the next (previous) circle, and each intermediate circle intersects only with the two neighboring circles.
Your task is to find the shortest path that satisfies the following conditions.
* The path connects the centers of the first circle and the last circle.
* The path is confined in the chain, that is, all the points on the path are located within or on at least one of the circles.
Figure E-1 shows an example of such a chain and the corresponding shortest path.
<image>
Figure E-1: An example chain and the corresponding shortest path
Input
The input consists of multiple datasets. Each dataset represents the shape of a chain in the following format.
> n
> x1 y1 r1
> x2 y2 r2
> ...
> xn yn rn
>
The first line of a dataset contains an integer n (3 β€ n β€ 100) representing the number of the circles. Each of the following n lines contains three integers separated by a single space. (xi, yi) and ri represent the center position and the radius of the i-th circle Ci. You can assume that 0 β€ xi β€ 1000, 0 β€ yi β€ 1000, and 1 β€ ri β€ 25.
You can assume that Ci and Ci+1 (1 β€ i β€ nβ1) intersect at two separate points. When j β₯ i+2, Ci and Cj are apart and either of them does not contain the other. In addition, you can assume that any circle does not contain the center of any other circle.
The end of the input is indicated by a line containing a zero.
Figure E-1 corresponds to the first dataset of Sample Input below. Figure E-2 shows the shortest paths for the subsequent datasets of Sample Input.
<image>
Figure E-2: Example chains and the corresponding shortest paths
Output
For each dataset, output a single line containing the length of the shortest chain-confined path between the centers of the first circle and the last circle. The value should not have an error greater than 0.001. No extra characters should appear in the output.
Sample Input
10
802 0 10
814 0 4
820 1 4
826 1 4
832 3 5
838 5 5
845 7 3
849 10 3
853 14 4
857 18 3
3
0 0 5
8 0 5
8 8 5
3
0 0 5
7 3 6
16 0 5
9
0 3 5
8 0 8
19 2 8
23 14 6
23 21 6
23 28 6
19 40 8
8 42 8
0 39 5
11
0 0 5
8 0 5
18 8 10
8 16 5
0 16 5
0 24 5
3 32 5
10 32 5
17 28 8
27 25 3
30 18 5
0
Output for the Sample Input
58.953437
11.414214
16.0
61.874812
63.195179
Example
Input
10
802 0 10
814 0 4
820 1 4
826 1 4
832 3 5
838 5 5
845 7 3
849 10 3
853 14 4
857 18 3
3
0 0 5
8 0 5
8 8 5
3
0 0 5
7 3 6
16 0 5
9
0 3 5
8 0 8
19 2 8
23 14 6
23 21 6
23 28 6
19 40 8
8 42 8
0 39 5
11
0 0 5
8 0 5
18 8 10
8 16 5
0 16 5
0 24 5
3 32 5
10 32 5
17 28 8
27 25 3
30 18 5
0
Output
58.953437
11.414214
16.0
61.874812
63.195179
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
/////////////////
// 2D geometry //
/////////////////
// 2D geometry basic //
const double EPS = 1e-8;
const double INF = 1e12;
typedef complex<double> P;
#define X real
#define Y imag
namespace std {
bool operator < (const P& a, const P& b) {
return real(a) != real(b) ? real(a) < real(b) : imag(a) < imag(b);
}
}
double cross(const P& a, const P& b) {
return imag(conj(a)*b);
}
double dot(const P& a, const P& b) {
return real(conj(a)*b);
}
struct L : public vector<P> {
L(const P &a, const P &b) {
push_back(a); push_back(b);
}
};
typedef vector<P> G;
struct C {
P p; double r;
C(const P &p, double r) : p(p), r(r) { }
};
int ccw(P a, P b, P c) {
b -= a; c -= a;
if (cross(b, c) > 0) return +1; // counter clockwise
if (cross(b, c) < 0) return -1; // clockwise
if (dot(b, c) < 0) return +2; // c--a--b on line
if (norm(b) < norm(c)) return -2; // a--b--c on line
return 0;
}
// UVA 453 (Intersecting Circles)
pair<P, P> circle_circle_intersect(const P& c1, const double& r1, const P& c2, const double& r2) {
P A = conj(c2-c1), B = (r2*r2-r1*r1-(c2-c1)*conj(c2-c1)), C = r1*r1*(c2-c1);
P D = B*B-4.0*A*C;
P z1 = (-B+sqrt(D))/(2.0*A)+c1, z2 = (-B-sqrt(D))/(2.0*A)+c1;
return pair<P, P>(z1, z2);
}
//////////
// data //
//////////
struct E{
int n1,n2;
double l;
};
bool operator<(E a,E b){
return a.l>b.l;
}
vector<C> in;
vector<vector<P>> node;
vector<vector<vector<E>>> edge;
void init(){
in.clear();
node.clear();
edge.clear();
}
bool input(){
int n;
cin>>n;
if(n==0)return false;
for(int i=0;i<n;i++){
double x,y,r;
cin>>x>>y>>r;
in.push_back(C(P(x,y),r));
}
return true;
}
double dist(int a,int b,int n,int m){
const P tmp = node[a][b]-node[n][m];
return sqrt(tmp.X()*tmp.X() + tmp.Y()*tmp.Y());
}
bool valid(int a,int b,int n,int m){
P vec = node[n][m] - node[a][b];
for(int i=a+1;i<n;i++){
int tmpa = ccw(node[a][b],node[n][m],node[i][0]);
int tmpb = ccw(node[a][b],node[n][m],node[i][1]);
if(!(abs(tmpa)==1 && tmpa==(-1*tmpb))){
return false;
}
}
return true;
}
void set_edge(int n,int m){
for(int i=0;i<n;i++){
for(int j=0;j<node[i].size();j++){
if(valid(i,j,n,m)){
edge[i][j].push_back(E{n,m,dist(i,j,n,m)});
}
}
}
}
void make_g(){
//make_node;
node.resize(in.size()+1);
node[0].push_back(in[0].p);
for(int i=1;i<in.size();i++){
auto tmp = circle_circle_intersect(in[i-1].p,in[i-1].r,in[i].p,in[i].r);
node[i].push_back(tmp.first);
node[i].push_back(tmp.second);
}
node[in.size()].push_back(in[in.size()-1].p);
//meke_edge
edge.resize(node.size());
for(int i=0;i<node.size();i++){
edge[i].resize(node[i].size());
for(int j=0;j<node[i].size();j++){
set_edge(i,j);
}
}
for(int i=0;i<edge.size();i++){
for(int j=0;j<edge[i].size();j++){
//cerr<<"node:"<<i<<","<<j<<endl;
for(int k=0;k<edge[i][j].size();k++){
//cerr<<" "<<edge[i][j][k].n1<<","<<edge[i][j][k].n2<<" "<<edge[i][j][k].l<<endl;
}
}
}
}
double solve_dist(){
priority_queue<E> q;
q.push(E{0,0,0});
vector<vector<double>> dp(node.size());
for(int i=0;i<dp.size();i++){
dp[i] = vector<double>(node[i].size(),-1);
}
while(!q.empty()){
E now = q.top();q.pop();
if(dp[now.n1][now.n2]!=-1)continue;
dp[now.n1][now.n2] = now.l;
const auto e = edge[now.n1][now.n2];
for(int i=0;i<e.size();i++){
q.push(E{e[i].n1,e[i].n2,now.l+e[i].l});
}
}
for(int i=0;i<dp.size();i++){
for(int j=0;j<dp[i].size();j++){
//cerr<<"("<<i<<","<<j<<")::"<<dp[i][j]<<endl;
}
}
return dp[node.size()-1][node[node.size()-1].size()-1];
}
long double solve(){
make_g();
return solve_dist();
}
int main(){
while(init(),input()){
cout<<fixed<<setprecision(10)<<solve()<<endl;
}
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
On the Berland Dependence Day it was decided to organize a great marathon. Berland consists of n cities, some of which are linked by two-way roads. Each road has a certain length. The cities are numbered from 1 to n. It is known that one can get from any city to any other one by the roads.
n runners take part in the competition, one from each city. But Berland runners are talkative by nature and that's why the juries took measures to avoid large crowds of marathon participants. The jury decided that every runner should start the marathon from their hometown. Before the start every sportsman will get a piece of paper containing the name of the city where the sportsman's finishing line is. The finish is chosen randomly for every sportsman but it can't coincide with the sportsman's starting point. Several sportsmen are allowed to finish in one and the same city. All the sportsmen start simultaneously and everyone runs the shortest route from the starting point to the finishing one. All the sportsmen run at one speed which equals to 1.
After the competition a follow-up table of the results will be composed where the sportsmen will be sorted according to the nondecrease of time they spent to cover the distance. The first g sportsmen in the table will get golden medals, the next s sportsmen will get silver medals and the rest will get bronze medals. Besides, if two or more sportsmen spend the same amount of time to cover the distance, they are sorted according to the number of the city where a sportsman started to run in the ascending order. That means no two sportsmen share one and the same place.
According to the rules of the competition the number of gold medals g must satisfy the inequation g1 β€ g β€ g2, where g1 and g2 are values formed historically. In a similar way, the number of silver medals s must satisfy the inequation s1 β€ s β€ s2, where s1 and s2 are also values formed historically.
At present, before the start of the competition, the destination points of every sportsman are unknown. However, the press demands details and that's why you are given the task of counting the number of the ways to distribute the medals. Two ways to distribute the medals are considered different if at least one sportsman could have received during those distributions different kinds of medals.
Input
The first input line contains given integers n and m (3 β€ n β€ 50, n - 1 β€ m β€ 1000), where n is the number of Berland towns and m is the number of roads.
Next in m lines road descriptions are given as groups of three integers v, u, c, which are the numbers of linked towns and its length (1 β€ v, u β€ n, v β u, 1 β€ c β€ 1000). Every pair of cities have no more than one road between them.
The last line contains integers g1, g2, s1, s2 (1 β€ g1 β€ g2, 1 β€ s1 β€ s2, g2 + s2 < n). The input data numbers, located on one line, are space-separated.
Output
Print the single number β the number of ways to distribute the medals. It is guaranteed that the number fits in the standard 64-bit signed data type.
Examples
Input
3 2
1 2 1
2 3 1
1 1 1 1
Output
3
Input
4 5
1 2 2
2 3 1
3 4 2
4 1 2
1 3 3
1 2 1 1
Output
19
Input
3 3
1 2 2
2 3 1
3 1 2
1 1 1 1
Output
4
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int INF = 100000;
int main() {
ios_base::sync_with_stdio(0);
int n, m;
cin >> n >> m;
vector<vector<int> > G(n, vector<int>(n, INF));
for (int i = 0; i < n; ++i) G[i][i] = 0;
for (int i = 0; i < m; ++i) {
int a, b, c;
cin >> a >> b >> c;
--a;
--b;
G[a][b] = c;
G[b][a] = c;
}
int g1, g2, s1, s2;
cin >> g1 >> g2 >> s1 >> s2;
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j)
for (int k = 0; k < n; ++k) G[j][k] = min(G[j][k], G[j][i] + G[i][k]);
vector<int> mini(n, INF), maxi(n, -INF);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (j != i) {
mini[i] = min(mini[i], G[i][j]);
maxi[i] = max(maxi[i], G[i][j]);
}
}
}
long long odp = 0;
for (int g = 0; g < n; ++g) {
for (int b = 0; b < n; ++b) {
if (mini[g] < maxi[b] || (mini[g] == maxi[b] && g < b)) {
vector<bool> srodek(n, false);
for (int s = 0; s < n; ++s)
if (s != g && s != b)
for (int i = 0; i < n; ++i)
if (i != s &&
(G[s][i] > mini[g] || (G[s][i] == mini[g] && s > g)) &&
(G[s][i] < maxi[b] || (G[s][i] == maxi[b] && s < b)))
srodek[s] = true;
long long dp[50][51][51];
for (int i = 0; i < 50; ++i)
for (int j = 0; j < 51; ++j)
for (int k = 0; k < 51; ++k) dp[i][j][k] = 0;
if (0 != b && (mini[0] < mini[g] || (mini[0] == mini[g] && 0 <= g)))
dp[0][1][0] = 1;
if (0 != b && 0 != g && srodek[0]) dp[0][0][0] = 1;
if (0 != g && (maxi[0] > maxi[b] || (maxi[0] == maxi[b] && 0 >= b)))
dp[0][0][1] = 1;
for (int i = 0; i < n - 1; ++i) {
for (int j = 0; j <= i + 1; ++j) {
for (int k = 0; k <= i + 1; ++k) {
if (i + 1 != b && (mini[i + 1] < mini[g] ||
(mini[i + 1] == mini[g] && i + 1 <= g)))
dp[i + 1][j + 1][k] += dp[i][j][k];
if (i + 1 != b && i + 1 != b && srodek[i + 1])
dp[i + 1][j][k] += dp[i][j][k];
if (i + 1 != g && (maxi[i + 1] > maxi[b] ||
(maxi[i + 1] == maxi[b] && i + 1 >= b)))
dp[i + 1][j][k + 1] += dp[i][j][k];
}
}
}
for (int i = g1; i <= g2; ++i)
for (int j = s1; j <= s2; ++j) odp += dp[n - 1][i][n - i - j];
}
}
}
cout << odp;
return 0;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
Write a program which calculates the area and circumference of a circle for given radius r.
Constraints
* 0 < r < 10000
Input
A real number r is given.
Output
Print the area and circumference of the circle in a line. Put a single space between them. The output should not contain an absolute error greater than 10-5.
Examples
Input
2
Output
12.566371 12.566371
Input
3
Output
28.274334 18.849556
### Response
```cpp
#include<iostream>
using namespace std;
int main(){
double a;
cin>>a;
cout<<fixed<<a*a*3.141592653589<<' '<<a*2*3.141592653589<<'\n';
return 0;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
N people are waiting in a single line in front of the Takahashi Store. The cash on hand of the i-th person from the front of the line is a positive integer A_i.
Mr. Takahashi, the shop owner, has decided on the following scheme: He picks a product, sets a positive integer P indicating its price, and shows this product to customers in order, starting from the front of the line. This step is repeated as described below.
At each step, when a product is shown to a customer, if price P is equal to or less than the cash held by that customer at the time, the customer buys the product and Mr. Takahashi ends the current step. That is, the cash held by the first customer in line with cash equal to or greater than P decreases by P, and the next step begins.
Mr. Takahashi can set the value of positive integer P independently at each step.
He would like to sell as many products as possible. However, if a customer were to end up with 0 cash on hand after a purchase, that person would not have the fare to go home. Customers not being able to go home would be a problem for Mr. Takahashi, so he does not want anyone to end up with 0 cash.
Help out Mr. Takahashi by writing a program that determines the maximum number of products he can sell, when the initial cash in possession of each customer is given.
Constraints
* 1 β¦ | N | β¦ 100000
* 1 β¦ A_i β¦ 10^9(1 β¦ i β¦ N)
* All inputs are integers.
Input
Inputs are provided from Standard Inputs in the following form.
N
A_1
:
A_N
Output
Output an integer representing the maximum number of products Mr. Takahashi can sell.
Examples
Input
3
3
2
5
Output
3
Input
15
3
1
4
1
5
9
2
6
5
3
5
8
9
7
9
Output
18
### Response
```cpp
#include <iostream>
#include <vector>
using namespace std;
int main(void){
long i,n,min=1,ans=0,a;
cin >> n;
for(i=0;i<n;i++){
cin >> a;
if(a==min){
min++;
continue;
}
ans+=(a-1)/min;
if(i==0) min++;
}
cout << ans;
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
Petya has n integers: 1, 2, 3, ..., n. He wants to split these integers in two non-empty groups in such a way that the absolute difference of sums of integers in each group is as small as possible.
Help Petya to split the integers. Each of n integers should be exactly in one group.
Input
The first line contains a single integer n (2 β€ n β€ 60 000) β the number of integers Petya has.
Output
Print the smallest possible absolute difference in the first line.
In the second line print the size of the first group, followed by the integers in that group. You can print these integers in arbitrary order. If there are multiple answers, print any of them.
Examples
Input
4
Output
0
2 1 4
Input
2
Output
1
1 1
Note
In the first example you have to put integers 1 and 4 in the first group, and 2 and 3 in the second. This way the sum in each group is 5, and the absolute difference is 0.
In the second example there are only two integers, and since both groups should be non-empty, you have to put one integer in the first group and one in the second. This way the absolute difference of sums of integers in each group is 1.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, i, j, k, l, sum = 0, t;
cin >> n;
sum = (n * (n + 1)) / 2;
t = ceil(n / 2.0);
if (sum % 2 == 0) {
cout << 0 << endl;
} else {
cout << 1 << endl;
}
long long int cnt = 0, p = 1, fc = 0;
vector<long long int> v;
for (i = n - 1; i > 0; i--) {
if (cnt < 2 && p == 1) {
cnt++;
v.push_back(i);
fc++;
} else if (cnt == 2 && p == 1) {
cnt = 0;
p = 0;
}
if (cnt < 2 && p == 0) {
cnt++;
if (cnt == 2) {
cnt = 0;
p = 1;
}
}
}
cout << fc << " ";
for (i = 0; i < fc; i++) {
cout << v[i] << " ";
}
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
Phoenix is playing with a new puzzle, which consists of n identical puzzle pieces. Each puzzle piece is a right isosceles triangle as shown below.
<image> A puzzle piece
The goal of the puzzle is to create a square using the n pieces. He is allowed to rotate and move the pieces around, but none of them can overlap and all n pieces must be used (of course, the square shouldn't contain any holes as well). Can he do it?
Input
The input consists of multiple test cases. The first line contains an integer t (1 β€ t β€ 10^4) β the number of test cases.
The first line of each test case contains an integer n (1 β€ n β€ 10^9) β the number of puzzle pieces.
Output
For each test case, if Phoenix can create a square with the n puzzle pieces, print YES. Otherwise, print NO.
Example
Input
3
2
4
6
Output
YES
YES
NO
Note
For n=2, Phoenix can create a square like this:
<image>
For n=4, Phoenix can create a square like this:
<image>
For n=6, it is impossible for Phoenix to create a square.
### Response
```cpp
#include<iostream>
#include <math.h>
using namespace std;
bool issquare(long int num)
{
long int sqrtnum=sqrt(num);
if(num==(sqrtnum*sqrtnum))
{
return true;
}
else{
return false;
}
}
int main()
{
int t;
cin>>t;
for(int i=0;i<t;i++)
{
int flag=0;
long int n;
cin>>n;
if(n%2==0)
{
long int k=n/2;
if(issquare(k))
flag=1;
}
if(flag==0)
{
if(n%4==0)
{
long int l=n/4;
if(issquare(l))
flag=1;
}
}
if(flag==1)
cout<<"YES"<<endl;
else
cout<<"NO"<<endl;
}
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
You are given a permutation of integers from 1 to n. Exactly once you apply the following operation to this permutation: pick a random segment and shuffle its elements. Formally:
1. Pick a random segment (continuous subsequence) from l to r. All <image> segments are equiprobable.
2. Let k = r - l + 1, i.e. the length of the chosen segment. Pick a random permutation of integers from 1 to k, p1, p2, ..., pk. All k! permutation are equiprobable.
3. This permutation is applied to elements of the chosen segment, i.e. permutation a1, a2, ..., al - 1, al, al + 1, ..., ar - 1, ar, ar + 1, ..., an is transformed to a1, a2, ..., al - 1, al - 1 + p1, al - 1 + p2, ..., al - 1 + pk - 1, al - 1 + pk, ar + 1, ..., an.
Inversion if a pair of elements (not necessary neighbouring) with the wrong relative order. In other words, the number of inversion is equal to the number of pairs (i, j) such that i < j and ai > aj. Find the expected number of inversions after we apply exactly one operation mentioned above.
Input
The first line contains a single integer n (1 β€ n β€ 100 000) β the length of the permutation.
The second line contains n distinct integers from 1 to n β elements of the permutation.
Output
Print one real value β the expected number of inversions. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 9.
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>.
Example
Input
3
2 3 1
Output
1.916666666666666666666666666667
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 5;
int a[maxn];
long long tree[maxn];
int n;
void add(int x, int y) {
for (int i = x; i <= n; i += (i & (-i))) tree[i] += y;
}
long long get(int x) {
long long ret = 0;
for (int i = x; i; i -= i & (-i)) ret += tree[i];
return ret;
}
int main() {
scanf("%d", &n);
double ans = 0;
double tmp = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
long long cnt = (i - get(a[i]));
ans += cnt;
add(a[i], 1);
long long l = i + 1;
tmp += (l * (l - 1) * (n - l + 1) / 4.0);
}
for (int i = 1; i <= n; i++) tree[i] = 0;
for (int i = 0; i < n; i++) {
long long cnt = get(n) - get(a[i]);
tmp -= cnt * (n - i);
add(a[i], i + 1);
}
tmp = tmp / (1.0 * n * (n + 1) / 2);
printf("%.11lf\n", ans + tmp);
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
The Little Elephant loves strings very much.
He has an array a from n strings, consisting of lowercase English letters. Let's number the elements of the array from 1 to n, then let's denote the element number i as ai. For each string ai (1 β€ i β€ n) the Little Elephant wants to find the number of pairs of integers l and r (1 β€ l β€ r β€ |ai|) such that substring ai[l... r] is a substring to at least k strings from array a (including the i-th string).
Help the Little Elephant solve this problem.
If you are not familiar with the basic notation in string problems, you can find the corresponding definitions in the notes.
Input
The first line contains two space-separated integers β n and k (1 β€ n, k β€ 105). Next n lines contain array a. The i-th line contains a non-empty string ai, consisting of lowercase English letter. The total length of all strings ai does not exceed 105.
Output
On a single line print n space-separated integers β the i-th number is the answer for string ai.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
3 1
abc
a
ab
Output
6 1 3
Input
7 4
rubik
furik
abab
baba
aaabbbababa
abababababa
zero
Output
1 0 9 9 21 30 0
Note
Let's assume that you are given string a = a1a2... a|a|, then let's denote the string's length as |a| and the string's i-th character as ai.
A substring a[l... r] (1 β€ l β€ r β€ |a|) of string a is string alal + 1... ar.
String a is a substring of string b, if there exists such pair of integers l and r (1 β€ l β€ r β€ |b|), that b[l... r] = a.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200010;
int n, m, K, lg[maxn], sa[maxn], st[maxn], ed[maxn], bel[maxn], num[maxn],
cnt[maxn];
int tmp[maxn], rk[maxn], ht[maxn], a[maxn], buc[maxn], fir[maxn], sec[maxn],
f[maxn][20];
char str[maxn], s[maxn];
void build_sa(int n) {
copy(s + 1, s + n + 1, num + 1);
sort(num + 1, num + n + 1);
int *end = unique(num + 1, num + n + 1);
for (int i = 1; i <= n; i++) a[i] = lower_bound(num + 1, end, s[i]) - num;
memset(buc, 0, sizeof(buc));
for (int i = 1; i <= n; i++) buc[a[i]]++;
for (int i = 1; i <= n; i++) buc[i] += buc[i - 1];
for (int i = 1; i <= n; i++) rk[i] = buc[a[i] - 1] + 1;
for (int k = 1; k <= n; k <<= 1) {
for (int i = 1; i <= n; i++) fir[i] = rk[i];
for (int i = 1; i <= n; i++) sec[i] = i + k > n ? 0 : rk[i + k];
memset(buc, 0, sizeof(buc));
for (int i = 1; i <= n; i++) buc[sec[i]]++;
for (int i = 1; i <= n; i++) buc[i] += buc[i - 1];
for (int i = 1; i <= n; i++) tmp[n - --buc[sec[i]]] = i;
memset(buc, 0, sizeof(buc));
for (int i = 1; i <= n; i++) buc[fir[i]]++;
for (int i = 1; i <= n; i++) buc[i] += buc[i - 1];
for (int i = 1; i <= n; i++) sa[buc[fir[tmp[i]]]--] = tmp[i];
bool unique = true;
rk[sa[1]] = 1;
for (int i = 1; i <= n; i++) {
rk[sa[i]] = rk[sa[i - 1]];
if (fir[sa[i]] == fir[sa[i - 1]] && sec[sa[i]] == sec[sa[i - 1]])
unique = false;
else
rk[sa[i]]++;
}
if (unique) break;
}
for (int i = 1, k = 0; i <= n; i++) {
if (k) k--;
int j = sa[rk[i] - 1];
while (i + k <= n && j + k <= n && a[i + k] == a[j + k]) k++;
ht[rk[i]] = k;
}
for (int i = 2; i <= n; i++) lg[i] = lg[i >> 1] + 1;
for (int i = 1; i <= n; i++) f[i][0] = ht[i];
for (int j = 1; j <= lg[n]; j++) {
for (int i = 1; i + (1 << j) - 1 <= n; i++) {
f[i][j] = min(f[i][j - 1], f[i + (1 << (j - 1))][j - 1]);
}
}
}
int lcp(int x, int y) {
int k = lg[y - x + 1];
return min(f[x][k], f[y - (1 << k) + 1][k]);
}
bool check(int x, int y) {
int p, q, l, r;
if (ht[x + 1] < y)
q = x;
else {
l = x + 1, r = m;
while (l <= r) {
int mid = (l + r) >> 1;
lcp(x + 1, mid) >= y ? l = mid + 1 : r = mid - 1;
}
q = r;
}
if (ht[x] < y)
p = x;
else {
l = 1, r = x - 1;
while (l <= r) {
int mid = (l + r) >> 1;
lcp(mid + 1, x) >= y ? r = mid - 1 : l = mid + 1;
}
p = l;
}
return num[q] >= p;
}
int main() {
scanf("%d %d", &n, &K);
for (int i = 1; i <= n; i++) {
scanf("%s", str), st[i] = m + 1;
for (int j = 0; str[j]; j++) bel[++m] = i, s[m] = str[j];
ed[i] = m, s[++m] = ' ';
}
build_sa(m);
memset(num, 0, sizeof(num));
for (int i = 1, j = 0, k = 1; i <= m; i++) {
if (!bel[sa[i]]) continue;
if (!cnt[bel[sa[i]]]++) j++;
if (j >= K) {
for (; j - (cnt[bel[sa[k]]] == 1) >= K; j -= !--(cnt[bel[sa[k++]]]))
;
num[i] = k;
}
}
for (int i = 1; i <= n; i++) {
long long ans = 0;
for (int j = st[i], k = 0; j <= ed[i]; j++) {
for (k ? k-- : 0; k <= ed[i] - j && check(rk[j], k + 1); k++)
;
ans += k;
}
printf("%lld ", ans);
}
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
Vus the Cossack has a simple graph with n vertices and m edges. Let d_i be a degree of the i-th vertex. Recall that a degree of the i-th vertex is the number of conected edges to the i-th vertex.
He needs to remain not more than β (n+m)/(2) β edges. Let f_i be the degree of the i-th vertex after removing. He needs to delete them in such way so that β (d_i)/(2) β β€ f_i for each i. In other words, the degree of each vertex should not be reduced more than twice.
Help Vus to remain the needed edges!
Input
The first line contains two integers n and m (1 β€ n β€ 10^6, 0 β€ m β€ 10^6) β the number of vertices and edges respectively.
Each of the next m lines contains two integers u_i and v_i (1 β€ u_i, v_i β€ n) β vertices between which there is an edge.
It is guaranteed that the graph does not have loops and multiple edges.
It is possible to show that the answer always exists.
Output
In the first line, print one integer k (0 β€ k β€ β (n+m)/(2) β) β the number of edges which you need to remain.
In each of the next k lines, print two integers u_i and v_i (1 β€ u_i, v_i β€ n) β the vertices, the edge between which, you need to remain. You can not print the same edge more than once.
Examples
Input
6 6
1 2
2 3
3 4
4 5
5 3
6 5
Output
5
2 1
3 2
5 3
5 4
6 5
Input
10 20
4 3
6 5
4 5
10 8
4 8
5 8
10 4
9 5
5 1
3 8
1 2
4 7
1 4
10 7
1 7
6 1
9 6
3 9
7 9
6 2
Output
12
2 1
4 1
5 4
6 5
7 1
7 4
8 3
8 5
9 3
9 6
10 4
10 7
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int M = 4200000;
namespace io {
const int L = (1 << 21) + 1;
char ibuf[L], *iS, *iT, obuf[L], *oS = obuf, *oT = obuf + L - 1, c, st[65];
int f, tp;
inline void flush() {
fwrite(obuf, 1, oS - obuf, stdout);
oS = obuf;
}
inline void putc(char x) {
*oS++ = x;
if (oS == oT) flush();
}
inline void read(int &x) {
for (f = 1, c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, L, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
c < '0' || c > '9';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, L, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
if (c == '-') f = -1;
for (x = 0; c <= '9' && c >= '0';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, L, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
x = x * 10 + (c & 15);
x *= f;
}
inline void print(int x) {
if (!x) putc('0');
if (x < 0) putc('-'), x = -x;
while (x) st[++tp] = x % 10 + '0', x /= 10;
while (tp) putc(st[tp--]);
}
inline void read(long long &x) {
for (f = 1, c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, L, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
c < '0' || c > '9';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, L, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
if (c == '-') f = -1;
for (x = 0; c <= '9' && c >= '0';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, L, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
x = x * 10 + (c & 15);
x *= f;
}
inline void print(long long x) {
if (!x) putc('0');
if (x < 0) putc('-'), x = -x;
while (x) st[++tp] = x % 10 + '0', x /= 10;
while (tp) putc(st[tp--]);
}
inline void read(char *s, int &l) {
for (c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, L, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
c < 33; c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, L, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
;
for (l = 0; c > 32;
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, L, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
s[l++] = c;
s[l] = '\0';
}
inline void read(char *s) {
int l;
for (c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, L, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
c < 33; c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, L, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
;
for (l = 0; c > 32;
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, L, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
s[l++] = c;
s[l] = '\0';
}
inline void print(char *s) {
for (int l = 0; s[l] != '\0'; ++l) putc(s[l]);
}
}; // namespace io
using io::print;
using io::putc;
using io::read;
struct edge {
int fr, to, nx;
} e[M];
int n, m;
int cnt = 2;
int h[M] = {0};
void add(int u, int v) {
e[cnt].fr = u;
e[cnt].nx = h[u];
e[cnt].to = v;
h[u] = cnt++;
}
int dgree[M] = {0};
int im;
bool vir(int x) { return x > im; }
int eula[M];
int tp = 0;
vector<int> ans;
bool vsp[M];
bool vse[M];
void dfs(int u, int p) {
vsp[u] = 1;
for (int &i = h[u]; i; i = e[i].nx) {
if (vse[i] || vse[i ^ 1]) continue;
vse[i] = 1;
dfs(e[i].to, i);
}
eula[tp++] = p;
}
bool del[M];
void solve(int x) {
tp = 0;
dfs(x, 0);
--tp;
for (int i = (0); i <= (tp); ++i) del[i] = 0;
for (int i = 1; i < tp; i += 2) {
int a = eula[i - 1], b = eula[i], c = eula[(i + 1) % tp];
if (b > im)
del[i] = 1;
else {
if (a > im)
del[i - 1] = 1;
else if (c > im)
del[(i + 1) % tp] = 1;
else
del[i] = 1;
}
}
for (int i = (0); i <= (tp - 1); ++i)
if (!del[i] && eula[i] <= im) {
ans.push_back(eula[i]);
}
}
int main() {
read(n);
read(m);
int u, v;
for (int i = (1); i <= (m); ++i) {
read(u);
read(v);
add(u, v);
add(v, u);
++dgree[u];
++dgree[v];
}
im = cnt - 1;
for (int i = (1); i <= (n); ++i)
if (dgree[i] & 1) {
add(i, 0);
add(0, i);
}
for (int i = (1); i <= (n); ++i)
if (!vsp[i]) solve(i);
print((int)ans.size());
putc('\n');
for (int i : ans) {
print(e[i].fr);
putc(' ');
print(e[i].to);
putc('\n');
}
io::flush();
return 0;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
You are given an array a consisting of n integers. You can perform the following operations with it:
1. Choose some positions i and j (1 β€ i, j β€ n, i β j), write the value of a_i β
a_j into the j-th cell and remove the number from the i-th cell;
2. Choose some position i and remove the number from the i-th cell (this operation can be performed no more than once and at any point of time, not necessarily in the beginning).
The number of elements decreases by one after each operation. However, the indexing of positions stays the same. Deleted numbers can't be used in the later operations.
Your task is to perform exactly n - 1 operations with the array in such a way that the only number that remains in the array is maximum possible. This number can be rather large, so instead of printing it you need to print any sequence of operations which leads to this maximum number. Read the output format to understand what exactly you need to print.
Input
The first line contains a single integer n (2 β€ n β€ 2 β
10^5) β the number of elements in the array.
The second line contains n integers a_1, a_2, ..., a_n (-10^9 β€ a_i β€ 10^9) β the elements of the array.
Output
Print n - 1 lines. The k-th line should contain one of the two possible operations.
The operation of the first type should look like this: 1~ i_k~ j_k, where 1 is the type of operation, i_k and j_k are the positions of the chosen elements.
The operation of the second type should look like this: 2~ i_k, where 2 is the type of operation, i_k is the position of the chosen element. Note that there should be no more than one such operation.
If there are multiple possible sequences of operations leading to the maximum number β print any of them.
Examples
Input
5
5 -2 0 1 -3
Output
2 3
1 1 2
1 2 4
1 4 5
Input
5
5 2 0 4 0
Output
1 3 5
2 5
1 1 2
1 2 4
Input
2
2 -1
Output
2 2
Input
4
0 -10 0 0
Output
1 1 2
1 2 3
1 3 4
Input
4
0 0 0 0
Output
1 1 2
1 2 3
1 3 4
Note
Let X be the removed number in the array. Let's take a look at all the examples:
The first example has, for example, the following sequence of transformations of the array: [5, -2, 0, 1, -3] β [5, -2, X, 1, -3] β [X, -10, X, 1, -3] β [X, X, X, -10, -3] β [X, X, X, X, 30]. Thus, the maximum answer is 30. Note, that other sequences that lead to the answer 30 are also correct.
The second example has, for example, the following sequence of transformations of the array: [5, 2, 0, 4, 0] β [5, 2, X, 4, 0] β [5, 2, X, 4, X] β [X, 10, X, 4, X] β [X, X, X, 40, X]. The following answer is also allowed:
1 5 3
1 4 2
1 2 1
2 3
Then the sequence of transformations of the array will look like this: [5, 2, 0, 4, 0] β [5, 2, 0, 4, X] β [5, 8, 0, X, X] β [40, X, 0, X, X] β [40, X, X, X, X].
The third example can have the following sequence of transformations of the array: [2, -1] β [2, X].
The fourth example can have the following sequence of transformations of the array: [0, -10, 0, 0] β [X, 0, 0, 0] β [X, X, 0, 0] β [X, X, X, 0].
The fifth example can have the following sequence of transformations of the array: [0, 0, 0, 0] β [X, 0, 0, 0] β [X, X, 0, 0] β [X, X, X, 0].
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5, inf = 1e9 + 7;
int n, s1, s2, sum, last;
int a[N];
pair<int, int> pa;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int main() {
n = read();
pa = make_pair(inf, 0);
for (int i = 1; i <= n; i++) {
a[i] = read();
if (a[i] == 0) s1++;
if (a[i] < 0) {
s2++;
pa = min(pa, make_pair(-a[i], i));
}
}
if (s2 & 1) a[pa.second] = 0;
last = -1;
for (int i = 1; i <= n; i++) {
if (a[i] != 0) continue;
if (last == -1)
last = i;
else {
printf("1 %d %d\n", last, i);
last = i;
sum++;
}
}
if (last != -1 && sum < n - 1) printf("2 %d\n", last);
last = -1;
for (int i = 1; i <= n; i++) {
if (a[i] == 0) continue;
if (last == -1)
last = i;
else {
printf("1 %d %d\n", last, i);
last = i;
}
}
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
You are going to work in Codeforces as an intern in a team of n engineers, numbered 1 through n. You want to give each engineer a souvenir: a T-shirt from your country (T-shirts are highly desirable in Codeforces). Unfortunately you don't know the size of the T-shirt each engineer fits in. There are m different sizes, numbered 1 through m, and each engineer will fit in a T-shirt of exactly one size.
You don't know the engineers' exact sizes, so you asked your friend, Gerald. Unfortunately, he wasn't able to obtain the exact sizes either, but he managed to obtain for each engineer i and for all sizes j, the probability that the size of the T-shirt that fits engineer i is j.
Since you're planning to give each engineer one T-shirt, you are going to bring with you exactly n T-shirts. For those n T-shirts, you can bring any combination of sizes (you can bring multiple T-shirts with the same size too!). You don't know the sizes of T-shirts for each engineer when deciding what sizes to bring, so you have to pick this combination based only on the probabilities given by your friend, Gerald.
Your task is to maximize the expected number of engineers that receive a T-shirt of his size.
This is defined more formally as follows. When you finally arrive at the office, you will ask each engineer his T-shirt size. Then, if you still have a T-shirt of that size, you will give him one of them. Otherwise, you don't give him a T-shirt. You will ask the engineers in order starting from engineer 1, then engineer 2, and so on until engineer n.
Input
The first line contains two space-separated integers n and m (1 β€ n β€ 3000, 1 β€ m β€ 300), denoting the number of engineers and the number of T-shirt sizes, respectively.
Then n lines follow, each line contains m space-separated integers. The j-th integer in the i-th line represents the probability that the i-th engineer fits in a T-shirt of size j. Each probability will be given as an integer between 0 and 1000, inclusive. The actual probability should be calculated as the given number divided by 1000.
It is guaranteed that for any engineer, the sum of the probabilities for all m T-shirts is equal to one.
Output
Print a single real number denoting the maximum possible expected number of engineers that will receive a T-shirt.
For the answer the absolute or relative error of 10 - 9 is acceptable.
Examples
Input
2 2
500 500
500 500
Output
1.500000000000
Input
3 3
1000 0 0
1000 0 0
0 1000 0
Output
3.000000000000
Input
1 4
100 200 300 400
Output
0.400000000000
Note
For the first example, bring one T-shirt of each size. With 0.5 chance, either both engineers fit inside T-shirts of size 1 or both fit inside T-shirts of size 2. With the other 0.5 chance, one engineer fits inside a T-shirt of size 1 and the other inside a T-shirt of size 2. If the first is true, the number of engineers that receive a T-shirt is one. If the second is true, the number of such engineers is two. Hence, the expected number of engineers who receive a T-shirt is 1.5. This is maximum possible expected number of engineers for all sets of T-shirts.
For the second example, bring two T-shirts of size 1 and one T-shirt of size 2. This way, each engineer will definitely receive a T-shirt of his size.
For the third example, bring one T-shirt of size 4.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int i, j, k, n, m, t;
int id[3310], ge[3310];
double a[3310][310], f[3310][3310], b[3310], an;
int main() {
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) scanf("%d", &k), a[i][j] = 1. * k / 1000;
for (j = 1; j <= m; j++) {
id[j] = ++t;
f[t][0] = 1;
for (i = 1; i <= n; i++) f[t][i] = f[t][i - 1] * (1 - a[i][j]);
b[j] = 1 - f[t][n];
}
for (k = 1; k <= n; k++) {
int re = 0;
double ma = 0;
for (j = 1; j <= m; j++)
if (b[j] > ma) ma = b[j], re = j;
an += ma;
int last = id[re], now = ++t;
id[re] = now;
for (i = 1; i <= n; i++)
f[now][i] = f[last][i - 1] * a[i][re] + f[now][i - 1] * (1 - a[i][re]);
b[re] -= f[now][n];
}
printf("%.11lf\n", an);
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
You have a statistic of price changes for one product represented as an array of n positive integers p_0, p_1, ..., p_{n - 1}, where p_0 is the initial price of the product and p_i is how the price was increased during the i-th month.
Using these price changes you are asked to calculate the inflation coefficients for each month as the ratio of current price increase p_i to the price at the start of this month (p_0 + p_1 + ... + p_{i - 1}).
Your boss said you clearly that the inflation coefficients must not exceed k %, so you decided to increase some values p_i in such a way, that all p_i remain integers and the inflation coefficients for each month don't exceed k %.
You know, that the bigger changes β the more obvious cheating. That's why you need to minimize the total sum of changes.
What's the minimum total sum of changes you need to make all inflation coefficients not more than k %?
Input
The first line contains a single integer t (1 β€ t β€ 1000) β the number of test cases.
The first line of each test case contains two integers n and k (2 β€ n β€ 100; 1 β€ k β€ 100) β the length of array p and coefficient k.
The second line of each test case contains n integers p_0, p_1, ..., p_{n - 1} (1 β€ p_i β€ 10^9) β the array p.
Output
For each test case, print the minimum total sum of changes you need to make all inflation coefficients not more than k %.
Example
Input
2
4 1
20100 1 202 202
3 100
1 1 1
Output
99
0
Note
In the first test case, you can, for example, increase p_0 by 50 and p_1 by 49 and get array [20150, 50, 202, 202]. Then you get the next inflation coefficients:
1. 50/20150 β€ 1/100;
2. (202)/(20150 + 50) β€ 1/100;
3. (202)/(20200 + 202) β€ 1/100;
In the second test case, you don't need to modify array p, since the inflation coefficients are already good:
1. 1/1 β€ 100/100;
2. (1)/(1 + 1) β€ 100/100;
### Response
```cpp
// 02/02/2021
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
#define CLR(a) memset(a, 0, sizeof(a))
#define REP(i, n) for(int i=0;i<n;i++)
#define FOR(i, n) for(int i=1;i<=n;i++)
#define all(c) (c).begin(), (c).end()
#define F first
#define S second
const int mxn = 1e2+2, MM = 1e9;
ll t(1), n, k, a[mxn], x, sum;
void solve() {
cin >> n >> k;
FOR(i, n) cin >> a[i];
x = 0; sum = a[1];
for(int i=2;i<=n;i++) {
x = max(x, (100ll*a[i]-k*sum+k-1)/k);
sum+=a[i];
}
cout << x << endl;
}
int main() {
ios::sync_with_stdio(0); cin.tie(0);
cin >> t;
for (int i=1;i<=t;i++) {
solve();
}
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
Sigma and Sugim are playing a game.
The game is played on a graph with N vertices numbered 1 through N. The graph has N-1 red edges and N-1 blue edges, and the N-1 edges in each color forms a tree. The red edges are represented by pairs of integers (a_i, b_i), and the blue edges are represented by pairs of integers (c_i, d_i).
Each player has his own piece. Initially, Sigma's piece is at vertex X, and Sugim's piece is at vertex Y.
The game is played in turns, where turns are numbered starting from turn 1. Sigma takes turns 1, 3, 5, ..., and Sugim takes turns 2, 4, 6, ....
In each turn, the current player either moves his piece, or does nothing. Here, Sigma can only move his piece to a vertex that is directly connected to the current vertex by a red edge. Similarly, Sugim can only move his piece to a vertex that is directly connected to the current vertex by a blue edge.
When the two pieces come to the same vertex, the game ends immediately. If the game ends just after the operation in turn i, let i be the total number of turns in the game.
Sigma's objective is to make the total number of turns as large as possible, while Sugim's objective is to make it as small as possible.
Determine whether the game will end in a finite number of turns, assuming both players plays optimally to achieve their respective objectives. If the answer is positive, find the number of turns in the game.
Constraints
* 2 β¦ N β¦ 200,000
* 1 β¦ X, Y β¦ N
* X \neq Y
* 1 β¦ a_i, b_i, c_i, d_i β¦ N
* The N-1 edges in each color (red and blue) forms a tree.
Input
The input is given from Standard Input in the following format:
N X Y
a_1 b_1
a_2 b_2
:
a_{N-1} b_{N-1}
c_1 d_1
c_2 d_2
:
c_{N-1} d_{N-1}
Output
If the game will end in a finite number of turns, print the number of turns. Otherwise, print `-1`.
Examples
Input
4 1 2
1 2
1 3
1 4
2 1
2 3
1 4
Output
4
Input
3 3 1
1 2
2 3
1 2
2 3
Output
4
Input
4 1 2
1 2
3 4
2 4
1 2
3 4
1 3
Output
2
Input
4 2 1
1 2
3 4
2 4
1 2
3 4
1 3
Output
-1
Input
5 1 2
1 2
1 3
1 4
4 5
2 1
1 3
1 5
5 4
Output
6
### Response
```cpp
#include<bits/stdc++.h>
#define N 200009
#define M 800009
using namespace std;
int n,rt,sta,tot,pnt[M],nxt[M]; bool bo[N];
int h[N],fa[N],dep[N],sz[N],son[N],anc[N],d[N];
struct graph{
int fst[N];
void add(int x,int y){
pnt[++tot]=y; nxt[tot]=fst[x]; fst[x]=tot;
}
}gr,gb;
void dfs(int x){
int i,y; sz[x]=1;
for (i=gb.fst[x]; i; i=nxt[i]){
y=pnt[i];
if (y!=fa[x]){
fa[y]=x; dep[y]=dep[x]+1;
dfs(y); sz[x]+=sz[y];
if (sz[y]>sz[son[x]]) son[x]=y;
}
}
}
void dvd(int x,int tp){
int i,y; anc[x]=tp;
if (son[x]) dvd(son[x],tp);
for (i=gb.fst[x]; i; i=nxt[i]){
y=pnt[i];
if (y!=fa[x] && y!=son[x]) dvd(y,y);
}
}
int lca(int x,int y){
for (; anc[x]!=anc[y]; x=fa[anc[x]])
if (dep[anc[x]]<dep[anc[y]]) swap(x,y);
return dep[x]<dep[y]?x:y;
}
int dist(int x,int y){
return dep[x]+dep[y]-(dep[lca(x,y)]<<1);
}
int main(){
scanf("%d%d%d",&n,&sta,&rt);
int i,j,x,y;
for (i=1; i<n; i++){
scanf("%d%d",&x,&y);
gr.add(x,y); gr.add(y,x);
}
for (i=1; i<n; i++){
scanf("%d%d",&x,&y);
gb.add(x,y); gb.add(y,x);
}
dfs(rt); dvd(rt,rt);
for (i=1; i<=n; i++)
for (j=gr.fst[i]; j; j=nxt[j])
if (dist(i,pnt[j])>2) bo[i]=1;
int head=0,tail=1,ans=0; h[1]=sta;
memset(d,-1,sizeof(d)); d[sta]=0;
while (head<tail){
x=h[++head];
if (bo[x]){ puts("-1"); return 0; }
ans=max(ans,dep[x]<<1);
for (i=gr.fst[x]; i; i=nxt[i]){
y=pnt[i];
if (d[y]==-1 && d[x]+1<dep[y]){
d[y]=d[x]+1; h[++tail]=y;
}
}
}
printf("%d\n",ans);
return 0;
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
Ichihime is the current priestess of the Mahjong Soul Temple. She claims to be human, despite her cat ears.
These days the temple is holding a math contest. Usually, Ichihime lacks interest in these things, but this time the prize for the winner is her favorite β cookies. Ichihime decides to attend the contest. Now she is solving the following problem.
<image>
You are given four positive integers a, b, c, d, such that a β€ b β€ c β€ d.
Your task is to find three integers x, y, z, satisfying the following conditions:
* a β€ x β€ b.
* b β€ y β€ c.
* c β€ z β€ d.
* There exists a triangle with a positive non-zero area and the lengths of its three sides are x, y, and z.
Ichihime desires to get the cookie, but the problem seems too hard for her. Can you help her?
Input
The first line contains a single integer t (1 β€ t β€ 1000) β the number of test cases.
The next t lines describe test cases. Each test case is given as four space-separated integers a, b, c, d (1 β€ a β€ b β€ c β€ d β€ 10^9).
Output
For each test case, print three integers x, y, z β the integers you found satisfying the conditions given in the statement.
It is guaranteed that the answer always exists. If there are multiple answers, print any.
Example
Input
4
1 3 5 7
1 5 5 7
100000 200000 300000 400000
1 1 977539810 977539810
Output
3 4 5
5 5 5
182690 214748 300999
1 977539810 977539810
Note
One of the possible solutions to the first test case:
<image>
One of the possible solutions to the second test case:
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int tc;
cin >> tc;
while (tc--) {
int a, b, c, d;
cin >> a >> b >> c >> d;
cout << b << " " << c << " " << c << endl;
}
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
This morning Tolik has understood that while he was sleeping he had invented an incredible problem which will be a perfect fit for Codeforces! But, as a "Discuss tasks" project hasn't been born yet (in English, well), he decides to test a problem and asks his uncle.
After a long time thinking, Tolik's uncle hasn't any ideas on how to solve it. But, he doesn't want to tell Tolik about his inability to solve it, so he hasn't found anything better than asking you how to solve this task.
In this task you are given a cell field n β
m, consisting of n rows and m columns, where point's coordinates (x, y) mean it is situated in the x-th row and y-th column, considering numeration from one (1 β€ x β€ n, 1 β€ y β€ m). Initially, you stand in the cell (1, 1). Every move you can jump from cell (x, y), which you stand in, by any non-zero vector (dx, dy), thus you will stand in the (x+dx, y+dy) cell. Obviously, you can't leave the field, but also there is one more important condition β you're not allowed to use one vector twice. Your task is to visit each cell of the field exactly once (the initial cell is considered as already visited).
Tolik's uncle is a very respectful person. Help him to solve this task!
Input
The first and only line contains two positive integers n, m (1 β€ n β
m β€ 10^{6}) β the number of rows and columns of the field respectively.
Output
Print "-1" (without quotes) if it is impossible to visit every cell exactly once.
Else print n β
m pairs of integers, i-th from them should contain two integers x_i, y_i (1 β€ x_i β€ n, 1 β€ y_i β€ m) β cells of the field in order of visiting, so that all of them are distinct and vectors of jumps between them are distinct too.
Notice that the first cell should have (1, 1) coordinates, according to the statement.
Examples
Input
2 3
Output
1 1
1 3
1 2
2 2
2 3
2 1
Input
1 1
Output
1 1
Note
The vectors from the first example in the order of making jumps are (0, 2), (0, -1), (1, 0), (0, 1), (0, -2).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 50;
int main() {
int n, m;
scanf("%d%d", &n, &m);
int l = 1;
int r = n;
while (l < r) {
for (int i = 1; i <= m; i++) {
printf("%d %d\n%d %d\n", l, i, r, m - i + 1);
}
l++;
r--;
}
if (l == r) {
for (int i = 1; i <= m / 2; i++) {
printf("%d %d\n%d %d\n", l, i, l, m - i + 1);
}
if (m % 2) {
printf("%d %d\n", l, m / 2 + 1);
}
}
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
Example
Input
2 3 1 3 1 0
Output
2
### Response
```cpp
#include <bits/stdc++.h>
#define ll long long
#define INF 1000000005
#define MOD 1000000007
#define EPS 1e-10
#define rep(i,n) for(int i=0;i<(int)(n);++i)
#define rrep(i,n) for(int i=(int)(n)-1;i>=0;--i)
#define srep(i,s,t) for(int i=(int)(s);i<(int)(t);++i)
#define each(a,b) for(auto& (a): (b))
#define all(v) (v).begin(),(v).end()
#define len(v) (int)(v).size()
#define zip(v) sort(all(v)),v.erase(unique(all(v)),v.end())
#define cmx(x,y) x=max(x,y)
#define cmn(x,y) x=min(x,y)
#define fi first
#define se second
#define pb push_back
#define show(x) cout<<#x<<" = "<<(x)<<endl
#define spair(p) cout<<#p<<": "<<p.fi<<" "<<p.se<<endl
#define sar(a,n) cout<<#a<<":";rep(pachico,n)cout<<" "<<a[pachico];cout<<endl
#define svec(v) cout<<#v<<":";rep(pachico,v.size())cout<<" "<<v[pachico];cout<<endl
#define svecp(v) cout<<#v<<":";each(pachico,v)cout<<" {"<<pachico.first<<":"<<pachico.second<<"}";cout<<endl
#define sset(s) cout<<#s<<":";each(pachico,s)cout<<" "<<pachico;cout<<endl
#define smap(m) cout<<#m<<":";each(pachico,m)cout<<" {"<<pachico.first<<":"<<pachico.second<<"}";cout<<endl
using namespace std;
typedef pair<int,int> P;
typedef pair<ll,ll> pll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<double> vd;
typedef vector<P> vp;
typedef vector<string> vs;
const int MAX_N = 2500005;
ll sa[MAX_N],sb[MAX_N];
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
ll m,n,u1,v1,u2,v2;
cin >> m >> n >> u1 >> v1 >> u2 >> v2;
vl a(m),b(n);
rep(i,m){
a[i] = u1;
u1 = (u1*58+v1) % (n+1);
}
rep(i,n){
b[i] = u2;
u2 = (u2*58+v2) % (m+1);
}
sort(all(a)),sort(all(b));
rep(i,m){
sa[i+1] = sa[i] + a[i];
}
rep(i,n){
sb[i+1] = sb[i] + b[i];
}
ll ans = (1LL << 60);
rep(i,m+1){
int cnt = upper_bound(all(b),i) - b.begin();
cmn(ans,sa[m-i]+i*(n-cnt)+sb[cnt]);
}
cout << ans << "\n";
return 0;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
The Olympic Games in Bercouver are in full swing now. Here everyone has their own objectives: sportsmen compete for medals, and sport commentators compete for more convenient positions to give a running commentary. Today the main sport events take place at three round stadiums, and the commentator's objective is to choose the best point of observation, that is to say the point from where all the three stadiums can be observed. As all the sport competitions are of the same importance, the stadiums should be observed at the same angle. If the number of points meeting the conditions is more than one, the point with the maximum angle of observation is prefered.
Would you, please, help the famous Berland commentator G. Berniev to find the best point of observation. It should be noted, that the stadiums do not hide each other, the commentator can easily see one stadium through the other.
Input
The input data consists of three lines, each of them describes the position of one stadium. The lines have the format x, y, r, where (x, y) are the coordinates of the stadium's center ( - 103 β€ x, y β€ 103), and r (1 β€ r β€ 103) is its radius. All the numbers in the input data are integer, stadiums do not have common points, and their centers are not on the same line.
Output
Print the coordinates of the required point with five digits after the decimal point. If there is no answer meeting the conditions, the program shouldn't print anything. The output data should be left blank.
Examples
Input
0 0 10
60 0 10
30 30 10
Output
30.00000 0.00000
### Response
```cpp
#include <bits/stdc++.h>
double t[5], temp;
double x_1, y_1, r1, x2, y2, r2, x3, y3, r3, X = 0.0, Y = 0.0;
int f = 0;
double check(double dx, double dy) {
double ret = 0.0;
t[0] = sqrt(((dx - x_1) * (dx - x_1)) + ((dy - y_1) * (dy - y_1))) / r1;
t[1] = sqrt(((dx - x2) * (dx - x2)) + ((dy - y2) * (dy - y2))) / r2;
t[2] = sqrt(((dx - x3) * (dx - x3)) + ((dy - y3) * (dy - y3))) / r3;
ret += ((t[0] - t[1]) * (t[0] - t[1]));
ret += ((t[1] - t[2]) * (t[1] - t[2]));
ret += ((t[2] - t[0]) * (t[2] - t[0]));
return ret;
}
int main() {
double s;
scanf("%lf%lf%lf", &x_1, &y_1, &r1);
scanf("%lf%lf%lf", &x2, &y2, &r2);
scanf("%lf%lf%lf", &x3, &y3, &r3);
X = (x2 + x3 + x_1) / 3 + 0.1;
Y = (y2 + y3 + y_1) / 3 + 0.1;
for (s = 1; s > (1e-6); f = 0) {
temp = check(X, Y);
if (temp > check(X + s, Y))
X += s, f = 1;
else if (temp > check(X - s, Y))
X -= s, f = 1;
else if (temp > check(X, Y + s))
Y += s, f = 1;
else if (temp > check(X, Y - s))
Y -= s, f = 1;
if (!f) s *= 0.7;
}
if (check(X, Y) < (1e-5)) printf("%.5lf %.5lf\n", X, Y);
return 0;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
Little Artem has invented a time machine! He could go anywhere in time, but all his thoughts of course are with computer science. He wants to apply this time machine to a well-known data structure: multiset.
Artem wants to create a basic multiset of integers. He wants these structure to support operations of three types:
1. Add integer to the multiset. Note that the difference between set and multiset is that multiset may store several instances of one integer.
2. Remove integer from the multiset. Only one instance of this integer is removed. Artem doesn't want to handle any exceptions, so he assumes that every time remove operation is called, that integer is presented in the multiset.
3. Count the number of instances of the given integer that are stored in the multiset.
But what about time machine? Artem doesn't simply apply operations to the multiset one by one, he now travels to different moments of time and apply his operation there. Consider the following example.
* First Artem adds integer 5 to the multiset at the 1-st moment of time.
* Then Artem adds integer 3 to the multiset at the moment 5.
* Then Artem asks how many 5 are there in the multiset at moment 6. The answer is 1.
* Then Artem returns back in time and asks how many integers 3 are there in the set at moment 4. Since 3 was added only at moment 5, the number of integers 3 at moment 4 equals to 0.
* Then Artem goes back in time again and removes 5 from the multiset at moment 3.
* Finally Artyom asks at moment 7 how many integers 5 are there in the set. The result is 0, since we have removed 5 at the moment 3.
Note that Artem dislikes exceptions so much that he assures that after each change he makes all delete operations are applied only to element that is present in the multiset. The answer to the query of the third type is computed at the moment Artem makes the corresponding query and are not affected in any way by future changes he makes.
Help Artem implement time travellers multiset.
Input
The first line of the input contains a single integer n (1 β€ n β€ 100 000) β the number of Artem's queries.
Then follow n lines with queries descriptions. Each of them contains three integers ai, ti and xi (1 β€ ai β€ 3, 1 β€ ti, xi β€ 109) β type of the query, moment of time Artem travels to in order to execute this query and the value of the query itself, respectively. It's guaranteed that all moments of time are distinct and that after each operation is applied all operations of the first and second types are consistent.
Output
For each ask operation output the number of instances of integer being queried at the given moment of time.
Examples
Input
6
1 1 5
3 5 5
1 2 5
3 6 5
2 3 5
3 7 5
Output
1
2
1
Input
3
1 1 1
2 2 1
3 3 1
Output
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 15;
struct Persistent {
int l, r, s;
Persistent() { l = r = s = 0; }
} t[N << 5];
int n, no, avail, root[N];
map<int, int> vis;
int squeeze(int x) {
if (vis.find(x) == vis.end()) vis[x] = ++no;
return vis[x];
}
int update(int pre, int b, int e, int pos, int v) {
int node = ++avail;
t[node] = t[pre];
if (b == e) {
t[node].s += v;
return node;
}
int m = (b + e) >> 1;
if (pos <= m)
t[node].l = update(t[node].l, b, m, pos, v);
else
t[node].r = update(t[node].r, m + 1, e, pos, v);
t[node].s = t[t[node].l].s + t[t[node].r].s;
return node;
}
int query(int node, int b, int e, int l, int r) {
if (e < l || b > r || b > e) return 0;
if (l <= b && e <= r) return t[node].s;
int m = (b + e) >> 1;
return query(t[node].l, b, m, l, r) + query(t[node].r, m + 1, e, l, r);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i += 1) {
int operation, t, x;
cin >> operation >> t >> x;
x = squeeze(x);
if (operation == 1) {
root[x] = update(root[x], 1, 1e9, t, +1);
} else if (operation == 2) {
root[x] = update(root[x], 1, 1e9, t, -1);
} else {
cout << query(root[x], 1, 1e9, 1, t) << '\n';
}
}
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
Goldbach's Conjecture: For any even number n greater than or equal to 4, there exists at least one pair of prime numbers p1 and p2 such that n = p1 + p2.
This conjecture has not been proved nor refused yet. No one is sure whether this conjecture actually holds. However, one can find such a pair of prime numbers, if any, for a given even number. The problem here is to write a program that reports the number of all the pairs of prime numbers satisfying the condition in the conjecture for a given even number.
A sequence of even numbers is given as input. Corresponding to each number, the program should output the number of pairs mentioned above. Notice that we are intereseted in the number of essentially different pairs and therefore you should not count (p1, p2) and (p2, p1) separately as two different pairs.
Input
An integer is given in each input line. You may assume that each integer is even, and is greater than or equal to 4 and less than 215. The end of the input is indicated by a number 0.
Output
Each output line should contain an integer number. No other characters should appear in the output.
Example
Input
6
10
12
0
Output
1
2
1
### Response
```cpp
#include<stdio.h>
#include<bitset>
int main()
{
const int N=65536;
std::bitset<N>p;
int i,j,n,r;
p.set();
for(i=2;i<N/2;++i)if(p[i])for(j=i*2;j<N;j+=i)p[j]=0;
while(scanf("%d",&n),n)
{
for(r=0,i=j=n/2;i>1;++j)if(p[i--]&&p[j])++r;
printf("%d\n",r);
}
return 0;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
Find the edit distance between given two words s1 and s2.
The disntace is the minimum number of single-character edits required to change one word into the other. The edits including the following operations:
* insertion: Insert a character at a particular position.
* deletion: Delete a character at a particular position.
* substitution: Change the character at a particular position to a different character
Constraints
* 1 β€ length of s1 β€ 1000
* 1 β€ length of s2 β€ 1000
Input
s1
s2
Two words s1 and s2 are given in the first line and the second line respectively. The words will consist of lower case characters.
Output
Print the edit distance in a line.
Examples
Input
acac
acm
Output
2
Input
icpc
icpc
Output
0
### Response
```cpp
#include <iostream>
#include <cstring>
#include <algorithm>
char s1[1000], s2[1000];
int dp[1001][1001];
int main()
{
std::cin >> s1 >> s2;
int s1_len = std::strlen(s1);
int s2_len = std::strlen(s2);
for (int i = 0; i < 1001; ++i)
{
dp[0][i] = i;
dp[i][0] = i;
}
for (int i = 1; i <= s1_len; ++i)
{
for (int j = 1; j <= s2_len; ++j)
{
if (s1[i - 1] == s2[j - 1])
{
dp[i][j] = dp[i - 1][j - 1];
}
else
{
dp[i][j] = std::min({dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + 1});
}
}
}
std::cout << dp[s1_len][s2_len] << std::endl;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
You are given an array a of n integers.
You want to make all elements of a equal to zero by doing the following operation exactly three times:
* Select a segment, for each number in this segment we can add a multiple of len to it, where len is the length of this segment (added integers can be different).
It can be proven that it is always possible to make all elements of a equal to zero.
Input
The first line contains one integer n (1 β€ n β€ 100 000): the number of elements of the array.
The second line contains n elements of an array a separated by spaces: a_1, a_2, ..., a_n (-10^9 β€ a_i β€ 10^9).
Output
The output should contain six lines representing three operations.
For each operation, print two lines:
* The first line contains two integers l, r (1 β€ l β€ r β€ n): the bounds of the selected segment.
* The second line contains r-l+1 integers b_l, b_{l+1}, ..., b_r (-10^{18} β€ b_i β€ 10^{18}): the numbers to add to a_l, a_{l+1}, β¦, a_r, respectively; b_i should be divisible by r - l + 1.
Example
Input
4
1 3 2 4
Output
1 1
-1
3 4
4 2
2 4
-3 -6 -6
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
struct _ {
ios_base::Init i;
_() { ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL); }
} _;
int dx[] = {-1, 0, 1, 0, -1, -1, 1, 1};
int dy[] = {0, 1, 0, -1, -1, 1, 1, -1};
int main() {
long long n;
cin >> n;
vector<long long> a(n);
for (long long i = 0; i <= n - 1; i++) cin >> a[i];
if (n == 1) {
cout << "1 1\n0\n1 1\n0\n1 1\n";
cout << -a[0];
return 0;
}
for (auto rep : {0, 1, 2}) {
if (rep == 0) {
cout << "1 " << n - 1 << "\n";
for (long long i = 0; i <= n - 2; i++) {
cout << (n - 1) * a[i] << " ";
a[i] += (n - 1) * a[i];
}
cout << "\n";
} else if (rep == 1) {
cout << n << " " << n << "\n";
cout << -a[n - 1] << "\n";
a[n - 1] = 0;
} else {
cout << "1 " << n << "\n";
for (long long i = 0; i <= n - 1; i++) cout << -a[i] << " ";
}
}
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
In one very old text file there was written Great Wisdom. This Wisdom was so Great that nobody could decipher it, even Phong β the oldest among the inhabitants of Mainframe. But still he managed to get some information from there. For example, he managed to learn that User launches games for pleasure β and then terrible Game Cubes fall down on the city, bringing death to those modules, who cannot win the game...
For sure, as guard Bob appeared in Mainframe many modules stopped fearing Game Cubes. Because Bob (as he is alive yet) has never been defeated by User, and he always meddles with Game Cubes, because he is programmed to this.
However, unpleasant situations can happen, when a Game Cube falls down on Lost Angles. Because there lives a nasty virus β Hexadecimal, who is... mmm... very strange. And she likes to play very much. So, willy-nilly, Bob has to play with her first, and then with User.
This time Hexadecimal invented the following entertainment: Bob has to leap over binary search trees with n nodes. We should remind you that a binary search tree is a binary tree, each node has a distinct key, for each node the following is true: the left sub-tree of a node contains only nodes with keys less than the node's key, the right sub-tree of a node contains only nodes with keys greater than the node's key. All the keys are different positive integer numbers from 1 to n. Each node of such a tree can have up to two children, or have no children at all (in the case when a node is a leaf).
In Hexadecimal's game all the trees are different, but the height of each is not lower than h. In this problem Β«heightΒ» stands for the maximum amount of nodes on the way from the root to the remotest leaf, the root node and the leaf itself included. When Bob leaps over a tree, it disappears. Bob gets the access to a Cube, when there are no trees left. He knows how many trees he will have to leap over in the worst case. And you?
Input
The input data contains two space-separated positive integer numbers n and h (n β€ 35, h β€ n).
Output
Output one number β the answer to the problem. It is guaranteed that it does not exceed 9Β·1018.
Examples
Input
3 2
Output
5
Input
3 3
Output
4
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int64_t dp[35 + 1][35 + 1];
int main() {
memset(dp, 0, sizeof(dp));
int n, h;
scanf("%d%d", &n, &h);
dp[0][0] = 1LL;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= i; ++j) {
int l = j - 1, r = i - j;
int ls = (l == 0) ? 0 : (log2(l) + 1);
int rs = (r == 0) ? 0 : (log2(r) + 1);
for (int lh = ls; lh <= l; ++lh) {
for (int rh = rs; rh <= r; ++rh) {
int mxh = max(lh, rh) + 1;
dp[i][mxh] += dp[l][lh] * dp[r][rh];
}
}
}
}
int64_t ans = 0;
for (int i = h; i <= n; ++i) {
ans += dp[n][i];
}
printf("%" PRId64 "\n", ans);
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Arkady decides to observe a river for n consecutive days. The river's water level on each day is equal to some real value.
Arkady goes to the riverside each day and makes a mark on the side of the channel at the height of the water level, but if it coincides with a mark made before, no new mark is created. The water does not wash the marks away. Arkady writes down the number of marks strictly above the water level each day, on the i-th day this value is equal to mi.
Define di as the number of marks strictly under the water level on the i-th day. You are to find out the minimum possible sum of di over all days. There are no marks on the channel before the first day.
Input
The first line contains a single positive integer n (1 β€ n β€ 105) β the number of days.
The second line contains n space-separated integers m1, m2, ..., mn (0 β€ mi < i) β the number of marks strictly above the water on each day.
Output
Output one single integer β the minimum possible sum of the number of marks strictly below the water level among all days.
Examples
Input
6
0 1 0 3 0 2
Output
6
Input
5
0 1 2 1 2
Output
1
Input
5
0 1 1 2 2
Output
0
Note
In the first example, the following figure shows an optimal case.
<image>
Note that on day 3, a new mark should be created because if not, there cannot be 3 marks above water on day 4. The total number of marks underwater is 0 + 0 + 2 + 0 + 3 + 1 = 6.
In the second example, the following figure shows an optimal case.
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long arr[1000000];
int main() {
long long n;
cin >> n;
long long maxi = 0;
multiset<long long, greater<long long> > mi;
for (long long i = 0; i < n; i++) {
cin >> arr[i];
maxi = max(maxi, arr[i]);
mi.insert(arr[i]);
}
long long tot = 0;
for (long long i = n - 1; i >= 0; i--) {
if (maxi > *mi.begin()) maxi--;
tot += maxi - arr[i];
mi.erase(mi.find(arr[i]));
}
cout << tot;
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
Dreamoon saw a large integer x written on the ground and wants to print its binary form out. Dreamoon has accomplished the part of turning x into its binary format. Now he is going to print it in the following manner.
He has an integer n = 0 and can only perform the following two operations in any order for unlimited times each:
1. Print n in binary form without leading zeros, each print will append to the right of previous prints.
2. Increase n by 1.
Let's define an ideal sequence as a sequence of operations that can successfully print binary representation of x without leading zeros and ends with a print operation (i.e. operation 1). Dreamoon wants to know how many different ideal sequences are there and the length (in operations) of the shortest ideal sequence.
The answers might be large so please print them modulo 1000000007 (109 + 7).
Let's define the string representation of an ideal sequence as a string of '1' and '2' where the i-th character in the string matches the i-th operation performed. Two ideal sequences are called different if their string representations are different.
Input
The single line of the input contains a binary integer representing x (1 β€ x < 25000) without leading zeros.
Output
The first line of the output should contain an integer representing the number of different ideal sequences modulo 1000000007 (109 + 7).
The second line of the output contains an integer representing the minimal length of an ideal sequence modulo 1000000007 (109 + 7).
Examples
Input
101
Output
1
6
Input
11010
Output
3
5
Note
For the first sample, the shortest and the only ideal sequence is Β«222221Β» of length 6.
For the second sample, there are three ideal sequences Β«21211Β», Β«212222222221Β», Β«222222222222222222222222221Β». Among them the shortest one has length 5.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5005;
const int inf = 1 << 29;
const int mod = 1000000007;
const double eps = 1e-8;
char ss[maxn];
int xi[maxn][13];
int lo(int x) {
int tp = 1, res = 0;
while (tp * 2 <= x) {
tp <<= 1;
res++;
}
return res;
}
struct suf {
int s[maxn];
int sa[maxn], t[maxn], t2[maxn], c[maxn], n, m;
int rank[maxn], h[maxn];
void init(int le) {
n = le;
m = 3;
for (int i = 0; i < n; i++) s[i] = ss[i] - '0';
s[n] = 0;
build();
rmq();
}
inline int lcp(int x, int y) {
if (x > y) swap(x, y);
return query(x + 1, y);
}
void rmq() {
for (int i = 0; i < n; i++) xi[i][0] = h[i];
for (int j = 1; j <= lo(n); j++)
for (int i = 0; i + (1 << j) - 1 < n; i++)
xi[i][j] = min(xi[i][j - 1], xi[i + (1 << (j - 1))][j - 1]);
}
int query(int x, int y) {
int k = lo(y - x + 1);
return min(xi[x][k], xi[y - (1 << k) + 1][k]);
}
void geth() {
int i, j, k = 0;
for (i = 0; i < n; i++) rank[sa[i]] = i;
for (i = 0; i < n; i++) {
if (k) k--;
if (!rank[i]) continue;
j = sa[rank[i] - 1];
while (s[i + k] == s[j + k]) k++;
h[rank[i]] = k;
}
}
void build() {
int i, *x = t, *y = t2;
for (i = 0; i < m; i++) c[i] = 0;
for (i = 0; i < n; i++) c[x[i] = s[i]]++;
for (i = 1; i < m; i++) c[i] += c[i - 1];
for (i = n - 1; i >= 0; i--) sa[--c[x[i]]] = i;
for (int k = 1; k <= n; k <<= 1) {
int p = 0;
for (i = n - k; i < n; i++) y[p++] = i;
for (i = 0; i < n; i++)
if (sa[i] >= k) y[p++] = sa[i] - k;
for (i = 0; i < m; i++) c[i] = 0;
for (i = 0; i < n; i++) c[x[y[i]]]++;
for (i = 1; i < m; i++) c[i] += c[i - 1];
for (i = n - 1; i >= 0; i--) sa[--c[x[y[i]]]] = y[i];
swap(x, y);
p = 1, x[sa[0]] = 0;
for (i = 1; i < n; i++) {
if (y[sa[i]] != y[sa[i - 1]])
x[sa[i]] = p++;
else if (sa[i] < n - k && sa[i - 1] < n - k)
x[sa[i]] = y[sa[i] + k] == y[sa[i - 1] + k] ? p - 1 : p++;
else
x[sa[i]] = p++;
}
if (p >= n) break;
m = p;
}
geth();
}
} st;
int dp[maxn][maxn], n;
int f(int l, int r) {
int tp = r * 2 - l;
if (tp > n) return -1;
if (st.lcp(st.rank[l], st.rank[r]) >= r - l) return tp;
if (st.rank[l] < st.rank[r]) return tp;
return tp + 1 > n ? -1 : tp + 1;
}
int g(int x, int y) {
if (!y) return x;
return min(x, y);
}
int ff(int l, int r) {
int res = 0, b = 1;
for (int i = r - 1; i >= l; i--) {
res = (res + (ss[i] - '0') * b) % mod;
b = (b * 2) % mod;
}
return res;
}
int main() {
scanf("%s", ss);
n = strlen(ss);
st.init(n);
dp[0][1] = 1;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (!dp[i][j]) continue;
dp[i][j + 1] = (dp[i][j + 1] + dp[i][j]) % mod;
if (ss[j] == '1') {
int p = f(i, j);
if (p != -1) {
dp[j][p] = (dp[j][p] + dp[i][j]) % mod;
}
}
}
}
int r = 0;
for (int i = 0; i < n; i++) r = (r + dp[i][n]) % mod;
printf("%d\n", r);
memset(dp, 0, sizeof(dp));
dp[0][1] = 1;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (!dp[i][j]) continue;
dp[i][j + 1] = g(dp[i][j], dp[i][j + 1]);
if (ss[j] == '1') {
int p = f(i, j);
if (p != -1) {
dp[j][p] = g(dp[i][j] + 1, dp[j][p]);
}
}
}
}
int la = 1;
for (int i = 0; i < n; i++) {
if (dp[i][n]) {
if (n - i >= 13)
r = (ff(i, n) + dp[i][n]) % mod;
else {
if (la) {
la = 0;
r = ff(i, n) + dp[i][n];
} else
r = min(r, ff(i, n) + dp[i][n]);
}
}
}
printf("%d\n", r);
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
Takahashi has K 500-yen coins. (Yen is the currency of Japan.) If these coins add up to X yen or more, print `Yes`; otherwise, print `No`.
Constraints
* 1 \leq K \leq 100
* 1 \leq X \leq 10^5
Input
Input is given from Standard Input in the following format:
K X
Output
If the coins add up to X yen or more, print `Yes`; otherwise, print `No`.
Examples
Input
2 900
Output
Yes
Input
1 501
Output
No
Input
4 2000
Output
Yes
### Response
```cpp
#include <iostream>
using namespace std;
int main(){
int N,X;
cin>>N>>X;
if(N*500<X)cout<<"No"<<endl;
else cout<<"Yes"<<endl;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
The German University in Cairo (GUC) dorm houses are numbered from 1 to n. Underground water pipes connect these houses together. Each pipe has certain direction (water can flow only in this direction and not vice versa), and diameter (which characterizes the maximal amount of water it can handle).
For each house, there is at most one pipe going into it and at most one pipe going out of it. With the new semester starting, GUC student and dorm resident, Lulu, wants to install tanks and taps at the dorms. For every house with an outgoing water pipe and without an incoming water pipe, Lulu should install a water tank at that house. For every house with an incoming water pipe and without an outgoing water pipe, Lulu should install a water tap at that house. Each tank house will convey water to all houses that have a sequence of pipes from the tank to it. Accordingly, each tap house will receive water originating from some tank house.
In order to avoid pipes from bursting one week later (like what happened last semester), Lulu also has to consider the diameter of the pipes. The amount of water each tank conveys should not exceed the diameter of the pipes connecting a tank to its corresponding tap. Lulu wants to find the maximal amount of water that can be safely conveyed from each tank to its corresponding tap.
Input
The first line contains two space-separated integers n and p (1 β€ n β€ 1000, 0 β€ p β€ n) β the number of houses and the number of pipes correspondingly.
Then p lines follow β the description of p pipes. The i-th line contains three integers ai bi di, indicating a pipe of diameter di going from house ai to house bi (1 β€ ai, bi β€ n, ai β bi, 1 β€ di β€ 106).
It is guaranteed that for each house there is at most one pipe going into it and at most one pipe going out of it.
Output
Print integer t in the first line β the number of tank-tap pairs of houses.
For the next t lines, print 3 integers per line, separated by spaces: tanki, tapi, and diameteri, where tanki β tapi (1 β€ i β€ t). Here tanki and tapi are indexes of tank and tap houses respectively, and diameteri is the maximum amount of water that can be conveyed. All the t lines should be ordered (increasingly) by tanki.
Examples
Input
3 2
1 2 10
2 3 20
Output
1
1 3 10
Input
3 3
1 2 20
2 3 10
3 1 5
Output
0
Input
4 2
1 2 60
3 4 50
Output
2
1 2 60
3 4 50
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
typedef struct {
int v, d;
} Edge_t;
const int maxn = 1005;
int ideg[maxn], odeg[maxn];
vector<Edge_t> E[maxn];
typedef struct tuple_t {
int s, e, d;
friend bool operator<(const tuple_t& a, const tuple_t& b) {
return a.s < b.s;
}
} tuple_t;
vector<tuple_t> ans;
tuple_t t;
void dfs(int u, int d) {
if (odeg[u] == 0 && u != t.s) {
t.d = d;
t.e = u;
ans.push_back(t);
return;
}
int v, d_;
for (int i = 0; i < ((int)(E[u]).size()); ++i) {
v = E[u][i].v;
d_ = E[u][i].d;
d_ = min(d_, d);
dfs(v, d_);
}
}
int main() {
ios::sync_with_stdio(false);
int n, m;
int u, v, d;
Edge_t e;
memset(ideg, 0, sizeof(ideg));
memset(odeg, 0, sizeof(odeg));
scanf("%d %d", &n, &m);
while (m--) {
scanf("%d %d %d", &u, &e.v, &e.d);
E[u].push_back(e);
++ideg[e.v];
++odeg[u];
}
for (int i = 1; i < n + 1; ++i) {
if (ideg[i] == 0) {
t.s = i;
dfs(i, INT_MAX);
}
}
sort((ans).begin(), (ans).end());
n = ((int)(ans).size());
printf("%d\n", n);
for (int i = 0; i < n; ++i)
printf("%d %d %d\n", ans[i].s, ans[i].e, ans[i].d);
return 0;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
I conducted an exit poll of the shopping amount at a department store. Create a program that takes the shopping amount data as input, calculates the average shopping amount per person, and outputs it. The number of people surveyed shall be 100,000 or less, and the shopping amount per person shall not exceed 1 million yen.
Input
The input is given in the following format:
n
v1
v2
::
vn
The first line gives the number of people surveyed n, and the following n lines give the integer vi representing the purchase amount of the ith person.
Output
Please output the average shopping amount (integer: rounded down to the nearest whole number) on one line.
Example
Input
6
12300
5600
33800
0
26495
52000
Output
21699
### Response
```cpp
#include <iostream>
#include <algorithm>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <numeric>
#include <bitset>
#include <cmath>
static const int MOD = 1000000007;
using ll = long long;
using u32 = unsigned;
using u64 = unsigned long long;
using namespace std;
template<class T> constexpr T INF = ::numeric_limits<T>::max()/32*15+208;
int main() {
int n;
cin >> n;
ll ans = 0;
for (int i = 0; i < n; ++i) {
int x;
scanf("%d", &x);
ans += x;
}
cout << ans/n << "\n";
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
There are some ambiguities when one writes Berland names with the letters of the Latin alphabet.
For example, the Berland sound u can be written in the Latin alphabet as "u", and can be written as "oo". For this reason, two words "ulyana" and "oolyana" denote the same name.
The second ambiguity is about the Berland sound h: one can use both "h" and "kh" to write it. For example, the words "mihail" and "mikhail" denote the same name.
There are n users registered on the Polycarp's website. Each of them indicated a name represented by the Latin letters. How many distinct names are there among them, if two ambiguities described above are taken into account?
Formally, we assume that two words denote the same name, if using the replacements "u" <image> "oo" and "h" <image> "kh", you can make the words equal. One can make replacements in both directions, in any of the two words an arbitrary number of times. A letter that resulted from the previous replacement can participate in the next replacements.
For example, the following pairs of words denote the same name:
* "koouper" and "kuooper". Making the replacements described above, you can make both words to be equal: "koouper" <image> "kuuper" and "kuooper" <image> "kuuper".
* "khun" and "kkkhoon". With the replacements described above you can make both words to be equal: "khun" <image> "khoon" and "kkkhoon" <image> "kkhoon" <image> "khoon".
For a given list of words, find the minimal number of groups where the words in each group denote the same name.
Input
The first line contains integer number n (2 β€ n β€ 400) β number of the words in the list.
The following n lines contain words, one word per line. Each word consists of only lowercase Latin letters. The length of each word is between 1 and 20 letters inclusive.
Output
Print the minimal number of groups where the words in each group denote the same name.
Examples
Input
10
mihail
oolyana
kooooper
hoon
ulyana
koouper
mikhail
khun
kuooper
kkkhoon
Output
4
Input
9
hariton
hkariton
buoi
kkkhariton
boooi
bui
khariton
boui
boi
Output
5
Input
2
alex
alex
Output
1
Note
There are four groups of words in the first example. Words in each group denote same name:
1. "mihail", "mikhail"
2. "oolyana", "ulyana"
3. "kooooper", "koouper"
4. "hoon", "khun", "kkkhoon"
There are five groups of words in the second example. Words in each group denote same name:
1. "hariton", "kkkhariton", "khariton"
2. "hkariton"
3. "buoi", "boooi", "boui"
4. "bui"
5. "boi"
In the third example the words are equal, so they denote the same name.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
string* input;
string* filteru;
int main(int argc, char* argv[]) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
input = new string[n];
filteru = new string[n];
for (int i = 0; i < n; i++) {
cin >> input[i];
}
for (int i = 0; i < n; i++) {
string s = input[i];
vector<char> v;
for (int j = 0; j < s.size(); j++) {
if (s[j] == 'u') {
v.push_back('o');
v.push_back('o');
} else {
v.push_back(s[j]);
}
}
string s2(v.begin(), v.end());
filteru[i] = s2;
}
set<string> distinct;
for (int i = 0; i < n; i++) {
string s = filteru[i];
vector<char> v;
char prev = s[s.size() - 1];
v.push_back(prev);
for (int j = s.size() - 2; j >= 0; j--) {
if (prev == 'h' && s[j] == 'k') {
prev = 'h';
} else {
v.push_back(s[j]);
prev = s[j];
}
}
reverse(v.begin(), v.end());
string s2(v.begin(), v.end());
distinct.insert(s2);
}
cout << distinct.size() << "\n";
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
Given are two strings s and t consisting of lowercase English letters. Determine if the number of non-negative integers i satisfying the following condition is finite, and find the maximum value of such i if the number is finite.
* There exists a non-negative integer j such that the concatenation of i copies of t is a substring of the concatenation of j copies of s.
Constraints
* 1 \leq |s| \leq 5 \times 10^5
* 1 \leq |t| \leq 5 \times 10^5
* s and t consist of lowercase English letters.
Input
Input is given from Standard Input in the following format:
s
t
Output
If the number of non-negative integers i satisfying the following condition is finite, print the maximum value of such i; if the number is infinite, print `-1`.
Examples
Input
abcabab
ab
Output
3
Input
aa
aaaaaaa
Output
-1
Input
aba
baaab
Output
0
### Response
```cpp
#pragma GCC target("avx")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#include<stdio.h>
#include<cstdio>
int v[1500001];
char s[1500001],t[500002];
void Zalgorithm(int N){
int i=1,j=0,k=0;
while(i<N){
while(i+j<N&&s[i+j]==s[j])++j;
v[i]=j;
if(!j){
++i;
continue;
}
k=1;
while(v[k]+k<j){
v[i+k]=v[k];
++k;
}
i+=k;
j-=k;
}
}
int i,j,K,que[500001],bf,ans,size;
int main(){
int N,ng=500001,mid;
std::fgets(t,1000000,stdin);
std::fgets(s,1000000,stdin);
while(ng-K>1){
mid=(ng+K)>>1;
(s[mid]?K:ng)=mid;
}
while(t[i]!='\n'){
s[K+i]=t[i];++i;
}
N=i;
i+=K;
int M=N+(K<<1);
while(i<M){
s[i++]=t[j++];
j*=j<N;
}
Zalgorithm(M);
for(i=0;i<N;++i){
if(v[i+K]<K)que[size++]=(i+K)%N;
}
for(i=0;i<N;++i){
if(i==size){
puts("-1");
return 0;
}
if(v[que[i]+=K]>=K){
que[size++]=que[i]%N;
if(bf<=i){
bf=size-1;
++ans;
}
}
}
printf("%d\n",ans);
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
The Committee for Research on Binary Viruses discovered a method of replication for a large family of viruses whose genetic codes are sequences of zeros and ones. Each virus originates from a single gene; for simplicity genes are denoted by integers from 0 to G - 1. At each moment in time a virus is a sequence of genes. When mutation occurs, one of the genes from the sequence is replaced by a certain sequence of genes, according to the mutation table. The virus stops mutating when it consists only of genes 0 and 1.
For instance, for the following mutation table: $$$ 2 β β¨ 0\ 1 β© \\\ 3 β β¨ 2\ 0\ 0β©\\\ 3 β β¨ 1\ 3β©\\\ 4 β β¨ 0\ 3\ 1\ 2β©\\\ 5 β β¨ 2\ 1β©\\\ 5 β β¨ 5β© a virus that initially consisted of a single gene 4, could have mutated as follows: β¨ 4 β© β β¨ \underline{0\ 3\ 1\ 2} β© β β¨ 0\ \underline{2\ 0\ 0}\ 1\ 2 β© β β¨ 0\ \underline{0\ 1}\ 0\ 0\ 1\ 2 β© β β¨ 0\ 0\ 1\ 0\ 0\ 1\ \underline{0\ 1} β© or in another way: β¨ 4 β© β β¨ \underline{0\ 3\ 1\ 2} β© β β¨ 0\ \underline{1\ 3}\ 1\ 2 β© β β¨ 0\ 1\ 3\ 1\ \underline{0\ 1} β© β β¨ 0\ 1\ \underline{2\ 0\ 0}\ 1\ 0\ 1 β© β β¨ 0\ 1\ \underline{0\ 1}\ 0\ 0\ 1\ 0\ 1 β© $$$
Viruses are detected by antibodies that identify the presence of specific continuous fragments of zeros and ones in the viruses' codes. For example, an antibody reacting to a fragment β¨ 0\ 0\ 1\ 0\ 0 β© will detect a virus β¨ 0\ 0\ 1\ 0\ 0\ 1\ 0\ 1 β©, but it will not detect a virus β¨ 0\ 1\ 0\ 1\ 0\ 0\ 1\ 0\ 1 β©.
For each gene from 2 to G-1, the scientists are wondering whether a given set of antibodies is enough to detect all viruses that can emerge through mutations from this gene. If not, they want to know the length of the shortest virus that cannot be detected.
It may happen that sometimes scientists don't have any antibodies. Then of course no virus can be detected, so the scientists are only interested in the length of the shortest possible virus that can emerge from the gene mutations.
Input
The first line of the input will contain three integers G, N and M (G > 2, N β₯ G - 2, M β₯ 0) specifying the number of genes, the number of rows in the mutation table, and the number of antibodies.
The following N lines contain descriptions of rows of the mutation table; each line begins with two integers a and k (2 β€ a < G, k β₯ 1), followed by a sequence of k integers b_1, b_2, β¦, b_k (0 β€ b_i < G), that encode the row $$$ a β β¨ b_1\ b_2\ β¦\ b_k β© $$$
The sum of all values k does not exceed 100. Every integer from 2 to G - 1 appears in the table as a at least once.
The next M lines contain descriptions of the antibodies; each such line begins with an integer β (β β₯ 1), followed by a sequence of β integers c_1, c_2, β¦, c_β (0 β€ c_i β€ 1), describing the antibody. The sum of all values β does not exceed 50.
Output
Your program needs to output exactly G - 2 lines, containing the answers for the subsequent genes from 2 to G - 1.
If all viruses that can mutate from this single gene can be detected by the given set of antibodies, you need to print the word "YES". You also need to print this if there are no viruses that could originate from this gene (it can happen when the sequences never stop mutating).
Otherwise you need to print the word "NO", followed by an integer denoting the minimal length of the undetectable virus. You can assume that for all the prepared input data this value will be smaller than 2^{63}.
Scoring
Subtasks:
1. (11 points) No antibodies (M = 0)
2. (14 points) N = G - 2
3. (25 points) One antibody (M = 1)
4. (32 points) The sum of all values β does not exceed 10
5. (18 points) No further constraints
Example
Input
6 6 2
2 2 0 1
3 3 2 0 0
3 2 1 3
4 4 0 3 1 2
5 2 2 1
5 1 5
2 1 1
5 0 0 1 0 0
Output
NO 2
NO 4
NO 9
YES
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0, f = 1;
char a = getchar();
for (; !isdigit(a); a = getchar())
if (a == '-') f = -1;
for (; isdigit(a); a = getchar()) x = x * 10 + a - '0';
return x * f;
}
const unsigned long long INF = 1ULL << 63;
const int N = 200 + 5;
const int M = 50 + 5;
int IG, IN, IM, n, ipt[N];
int issuf[N];
int vis[N][M][M];
unsigned long long f[N][M][M];
vector<pair<int, int> > ed[N];
int ch[M][2], fail[M * 2], ok[M * 2], tot = 1;
void ins(int *A, int len) {
int x = 1;
for (int i = 1; i <= len; i++) {
if (!ch[x][A[i]]) ch[x][A[i]] = ++tot;
x = ch[x][A[i]];
}
ok[x] = 1;
}
void buildfail() {
queue<int> q;
for (int i = 0; i <= 1; i++)
if (ch[1][i])
fail[ch[1][i]] = 1, q.push(ch[1][i]);
else
ch[1][i] = 1;
while (q.size()) {
int x = q.front();
q.pop();
for (int i = 0; i <= 1; i++)
if (ch[x][i]) {
fail[ch[x][i]] = ch[fail[x]][i];
ok[ch[x][i]] |= ok[fail[ch[x][i]]];
q.push(ch[x][i]);
} else
ch[x][i] = ch[fail[x]][i];
}
}
int id[M * 2], loc[M * 2];
struct Node {
int x, fr, to;
unsigned long long val;
Node(int X = 0, int F = 0, int T = 0, unsigned long long V = 0)
: x(X), fr(F), to(T), val(V) {}
inline friend bool operator<(const Node &a, const Node &b) {
return a.val > b.val;
}
};
priority_queue<Node> hp;
int main() {
IG = read() - 1;
IN = read();
IM = read();
n = IG;
for (int i = 1; i <= IN; i++) {
int a = read(), k = read();
for (int j = 1; j <= k; j++) ipt[j] = read(), issuf[j + n] = 1;
for (int j = 2; j <= k; j++) {
ed[n + j].push_back({n + j - 1, ipt[j - 1]});
ed[ipt[j - 1]].push_back({n + j - 1, n + j});
}
ed[ipt[k]].push_back({n + k, -1});
ed[n + 1].push_back({a, -1});
n += k;
}
for (int i = 1; i <= IM; i++) {
int len = read();
for (int j = 1; j <= len; j++) ipt[j] = read();
ins(ipt, len);
}
buildfail();
int cnt = 0;
for (int i = 1; i <= tot; i++)
if (ok[i] == 0) id[i] = ++cnt, loc[cnt] = i;
for (int i = 0; i <= n; i++)
for (int j = 1; j <= cnt; j++)
for (int k = 1; k <= cnt; k++) f[i][j][k] = INF;
for (int i = 1; i <= cnt; i++) {
int x = loc[i];
if (id[ch[x][0]]) {
f[0][i][id[ch[x][0]]] = 1;
hp.push(Node(0, i, id[ch[x][0]], 1));
}
if (id[ch[x][1]]) {
f[1][i][id[ch[x][1]]] = 1;
hp.push(Node(1, i, id[ch[x][1]], 1));
}
}
while (hp.size()) {
Node tmp = hp.top();
hp.pop();
int x = tmp.x, fr = tmp.fr, to = tmp.to;
unsigned long long val = tmp.val;
if (vis[x][fr][to]) continue;
vis[x][fr][to] = 1;
for (auto e : ed[x]) {
int y = e.first, w = e.second;
if (w == -1) {
if (f[y][fr][to] > val) {
f[y][fr][to] = val;
hp.push(Node(y, fr, to, f[y][fr][to]));
}
} else {
if (issuf[x] == 0) {
for (int j = 1; j <= cnt; j++)
if (f[y][fr][j] > val + f[w][to][j]) {
f[y][fr][j] = val + f[w][to][j];
hp.push(Node(y, fr, j, f[y][fr][j]));
}
} else {
for (int j = 1; j <= cnt; j++)
if (f[y][j][to] > f[w][j][fr] + val) {
f[y][j][to] = f[w][j][fr] + val;
hp.push(Node(y, j, to, f[y][j][to]));
}
}
}
}
}
for (int i = 2; i <= IG; i++) {
unsigned long long ans = INF;
for (int j = 1; j <= cnt; j++) ans = min(ans, f[i][1][j]);
if (ans == INF)
printf("YES\n");
else
printf("NO %lld\n", ans);
}
return 0;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
You are organizing a boxing tournament, where n boxers will participate (n is a power of 2), and your friend is one of them. All boxers have different strength from 1 to n, and boxer i wins in the match against boxer j if and only if i is stronger than j.
The tournament will be organized as follows: n boxers will be divided into pairs; the loser in each pair leaves the tournament, and n/2 winners advance to the next stage, where they are divided into pairs again, and the winners in all pairs advance to the next stage, and so on, until only one boxer remains (who is declared the winner).
Your friend really wants to win the tournament, but he may be not the strongest boxer. To help your friend win the tournament, you may bribe his opponents: if your friend is fighting with a boxer you have bribed, your friend wins even if his strength is lower.
Furthermore, during each stage you distribute the boxers into pairs as you wish.
The boxer with strength i can be bribed if you pay him a_i dollars. What is the minimum number of dollars you have to spend to make your friend win the tournament, provided that you arrange the boxers into pairs during each stage as you wish?
Input
The first line contains one integer n (2 β€ n β€ 2^{18}) β the number of boxers. n is a power of 2.
The second line contains n integers a_1, a_2, ..., a_n, where a_i is the number of dollars you have to pay if you want to bribe the boxer with strength i. Exactly one of a_i is equal to -1 β it means that the boxer with strength i is your friend. All other values are in the range [1, 10^9].
Output
Print one integer β the minimum number of dollars you have to pay so your friend wins.
Examples
Input
4
3 9 1 -1
Output
0
Input
8
11 -1 13 19 24 7 17 5
Output
12
Note
In the first test case no matter how you will distribute boxers into pairs, your friend is the strongest boxer and anyway wins the tournament.
In the second test case you can distribute boxers as follows (your friend is number 2):
1 : 2, 8 : 5, 7 : 3, 6 : 4 (boxers 2, 8, 7 and 6 advance to the next stage);
2 : 6, 8 : 7 (boxers 2 and 8 advance to the next stage, you have to bribe the boxer with strength 6);
2 : 8 (you have to bribe the boxer with strength 8);
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = (1 << 20) + 5;
const int mod = 10007;
int a[N];
priority_queue<int, vector<int>, greater<int> > q;
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
int p = n >> 1;
long long ans = 0;
int now = n;
q.push(a[n]);
if (a[n] == -1) {
puts("0");
return 0;
}
while (1) {
ans += q.top();
q.pop();
int t = p;
while (t--) {
now--;
if (a[now] == -1) {
printf("%lld", ans);
return 0;
}
q.push(a[now]);
}
p >>= 1;
}
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
In Takahashi Kingdom, which once existed, there are N cities, and some pairs of cities are connected bidirectionally by roads. The following are known about the road network:
* People traveled between cities only through roads. It was possible to reach any city from any other city, via intermediate cities if necessary.
* Different roads may have had different lengths, but all the lengths were positive integers.
Snuke the archeologist found a table with N rows and N columns, A, in the ruin of Takahashi Kingdom. He thought that it represented the shortest distances between the cities along the roads in the kingdom.
Determine whether there exists a road network such that for each u and v, the integer A_{u, v} at the u-th row and v-th column of A is equal to the length of the shortest path from City u to City v. If such a network exist, find the shortest possible total length of the roads.
Constraints
* 1 \leq N \leq 300
* If i β j, 1 \leq A_{i, j} = A_{j, i} \leq 10^9.
* A_{i, i} = 0
Inputs
Input is given from Standard Input in the following format:
N
A_{1, 1} A_{1, 2} ... A_{1, N}
A_{2, 1} A_{2, 2} ... A_{2, N}
...
A_{N, 1} A_{N, 2} ... A_{N, N}
Outputs
If there exists no network that satisfies the condition, print `-1`. If it exists, print the shortest possible total length of the roads.
Examples
Input
3
0 1 3
1 0 2
3 2 0
Output
3
Input
3
0 1 3
1 0 1
3 1 0
Output
-1
Input
5
0 21 18 11 28
21 0 13 10 26
18 13 0 23 13
11 10 23 0 17
28 26 13 17 0
Output
82
Input
3
0 1000000000 1000000000
1000000000 0 1000000000
1000000000 1000000000 0
Output
3000000000
### Response
```cpp
#include<bits//stdc++.h>
#define rep(i,n) for(int i = 0;i < n;i++)
using namespace std;
typedef long long int ll;
int main() {
int n; cin >> n; ll ans= 0; vector<vector<ll>> dp(n, vector<ll>(n,1)), G(n, vector<ll>(n));
rep(i, n) rep(j, n) cin >> G[i][j];
rep(i, n) {
rep(j, n) {
rep(k, n) {
if (G[i][j] > G[i][k] + G[k][j]) {
cout << -1 << endl;
return 0;
}
else if (k != i && k != j && G[i][j] == G[i][k] + G[k][j])dp[i][j] = 0;
}
}
}
rep(i, n) rep(j, n) if (dp[i][j]) ans += G[i][j];
cout << ans/2 << endl;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
Gerda is travelling to the palace of the Snow Queen.
The road network consists of n intersections and m bidirectional roads. Roads are numbered from 1 to m. Snow Queen put a powerful spell on the roads to change the weather conditions there. Now, if Gerda steps on the road i at the moment of time less or equal to i, she will leave the road exactly at the moment i. In case she steps on the road i at the moment of time greater than i, she stays there forever.
Gerda starts at the moment of time l at the intersection number s and goes to the palace of the Snow Queen, located at the intersection number t. Moreover, she has to be there at the moment r (or earlier), before the arrival of the Queen.
Given the description of the road network, determine for q queries li, ri, si and ti if it's possible for Gerda to get to the palace on time.
Input
The first line of the input contains integers n, m and q (2 β€ n β€ 1000, 1 β€ m, q β€ 200 000) β the number of intersections in the road network of Snow Queen's Kingdom, the number of roads and the number of queries you have to answer.
The i-th of the following m lines contains the description of the road number i. The description consists of two integers vi and ui (1 β€ vi, ui β€ n, vi β ui) β the indices of the intersections connected by the i-th road. It's possible to get both from vi to ui and from ui to vi using only this road. Each pair of intersection may appear several times, meaning there are several roads connecting this pair.
Last q lines contain the queries descriptions. Each of them consists of four integers li, ri, si and ti (1 β€ li β€ ri β€ m, 1 β€ si, ti β€ n, si β ti) β the moment of time Gerda starts her journey, the last moment of time she is allowed to arrive to the palace, the index of the starting intersection and the index of the intersection where palace is located.
Output
For each query print "Yes" (without quotes) if Gerda can be at the Snow Queen palace on time (not later than ri) or "No" (without quotes) otherwise.
Example
Input
5 4 6
1 2
2 3
3 4
3 5
1 3 1 4
1 3 2 4
1 4 4 5
1 4 4 1
2 3 1 4
2 2 2 3
Output
Yes
Yes
Yes
No
No
Yes
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <typename T>
using v = vector<T>;
struct query {
int i, l, r, s, t;
query() {}
query(int i_, int l_, int r_, int s_, int t_)
: i(i_), l(l_), r(r_), s(s_), t(t_) {}
};
const int N = 1000;
const int M = 200000;
const int INF = numeric_limits<int>::max();
int A[N + 1][N + 1];
int E[M + 1][2];
v<v<query>> Q(M + 1);
bitset<M + 1> result;
int main(int argc, char const* argv[]) {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int a, b, c, d;
int n, m, q;
scanf("%d %d %d", &n, &m, &q);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
A[i][j] = INF;
}
}
for (int i = 1; i <= m; i++) {
scanf("%d %d", &E[i][0], &E[i][1]);
}
for (int i = 1; i <= q; i++) {
scanf("%d %d %d %d", &a, &b, &c, &d);
Q[a].push_back(query(i, a, b, c, d));
}
int u, v;
for (int e = m; e >= 1; e--) {
u = E[e][0];
v = E[e][1];
for (int i = 1; i <= n; i++) {
if (A[u][i] < A[v][i]) {
A[v][i] = A[u][i];
} else {
A[u][i] = A[v][i];
}
}
A[u][v] = e;
A[v][u] = e;
for (const query& curq : Q[e]) {
result[curq.i] = (A[curq.s][curq.t] <= curq.r);
}
}
for (ll i = 1; i <= q; i++) {
printf("%s\n", (result[i] ? "Yes" : "No"));
}
return 0;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
You are given an undirected graph where each edge has one of two colors: black or red.
Your task is to assign a real number to each node so that:
* for each black edge the sum of values at its endpoints is 1;
* for each red edge the sum of values at its endpoints is 2;
* the sum of the absolute values of all assigned numbers is the smallest possible.
Otherwise, if it is not possible, report that there is no feasible assignment of the numbers.
Input
The first line contains two integers N (1 β€ N β€ 100 000) and M (0 β€ M β€ 200 000): the number of nodes and the number of edges, respectively. The nodes are numbered by consecutive integers: 1, 2, β¦, N.
The next M lines describe the edges. Each line contains three integers a, b and c denoting that there is an edge between nodes a and b (1 β€ a, b β€ N) with color c (1 denotes black, 2 denotes red).
Output
If there is a solution, the first line should contain the word "YES" and the second line should contain N space-separated numbers. For each i (1 β€ i β€ N), the i-th number should be the number assigned to the node i.
Output should be such that:
* the sum of the numbers at the endpoints of each edge differs from the precise value by less than 10^{-6};
* the sum of the absolute values of all assigned numbers differs from the smallest possible by less than 10^{-6}.
If there are several valid solutions, output any of them.
If there is no solution, the only line should contain the word "NO".
Scoring
Subtasks:
1. (5 points) N β€ 5, M β€ 14
2. (12 points) N β€ 100
3. (17 points) N β€ 1000
4. (24 points) N β€ 10 000
5. (42 points) No further constraints
Examples
Input
4 4
1 2 1
2 3 2
1 3 2
3 4 1
Output
YES
0.5 0.5 1.5 -0.5
Input
2 1
1 2 1
Output
YES
0.3 0.7
Input
3 2
1 2 2
2 3 2
Output
YES
0 2 0
Input
3 4
1 2 2
2 2 1
2 1 1
1 2 2
Output
NO
Note
Note that in the second example the solution is not unique.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
void program();
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
program();
}
const int MX = 5e5;
const long long EPS = 1e-16;
int n, m;
vector<pair<int, int> > adj[MX];
long long x[MX], a[MX], b[MX];
bitset<MX> visited;
long long mustX = -1e10;
vector<long long> f;
bool possible = 1;
void resetVisited(int u) {
if (!visited[u]) return;
visited[u] = 0;
for (pair<int, int> v : adj[u]) resetVisited(v.first);
}
void dfsXA(int u, long long nx, long long na) {
if (visited[u]) {
if (x[u] == nx) {
if (a[u] != na) possible = 0;
} else {
mustX = (na - a[u]) * 2 / (x[u] - nx);
}
return;
}
visited[u] = 1;
x[u] = nx;
a[u] = na;
for (pair<int, int> p : adj[u]) {
int v = p.first;
long long c = p.second;
dfsXA(v, -nx, c - na);
}
}
bool dfsPossible(int u) {
if (visited[u]) return 1;
visited[u] = 1;
for (pair<int, int> p : adj[u]) {
int v = p.first;
long long c = p.second;
if (!dfsPossible(v)) return 0;
if (b[u] + b[v] != 2 * c) return 0;
}
return 1;
}
long long dfsSet(int u, long long X) {
if (visited[u]) return 0;
visited[u] = 1;
b[u] = x[u] * X + a[u] * 2;
long long ans = fabs(b[u]);
for (pair<int, int> v : adj[u]) ans += dfsSet(v.first, X);
return ans;
}
long long getTot(int u, long long X) {
resetVisited(u);
return dfsSet(u, X);
}
void dfsList(int u) {
if (visited[u]) return;
visited[u] = 1;
f.push_back(-x[u] * a[u]);
for (pair<int, int> v : adj[u]) dfsList(v.first);
}
int SA[MX];
void program() {
scanf("%d%d", &n, &m);
for (int i = int(0); i < int(m); i++) {
int u, v, c;
scanf("%d%d%d", &u, &v, &c);
adj[u].push_back({v, c});
adj[v].push_back({u, c});
}
visited.reset();
for (int u = int(1); u < int(n + 1); u++) {
if (visited[u]) continue;
possible = 1;
mustX = -1e10;
dfsXA(u, 1, 0);
if (!possible) {
cout << "NO\n";
return;
}
if (mustX != -1e10) {
resetVisited(u);
dfsSet(u, mustX);
resetVisited(u);
if (!dfsPossible(u)) {
cout << "NO\n";
return;
}
} else {
f.clear();
resetVisited(u);
dfsList(u);
sort(f.begin(), f.end());
int N = f.size();
long long best = f[(N - 1) / 2];
getTot(u, best * 2);
}
}
cout << "YES\n";
for (int i = int(1); i < int(n + 1); i++) {
if (i != 1) cout << " ";
cout << (double)(b[i]) / 2.0;
}
cout << "\n";
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
Once again Tavas started eating coffee mix without water! Keione told him that it smells awful, but he didn't stop doing that. That's why Keione told his smart friend, SaDDas to punish him! SaDDas took Tavas' headphones and told him: "If you solve the following problem, I'll return it to you."
<image>
The problem is:
You are given a lucky number n. Lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
If we sort all lucky numbers in increasing order, what's the 1-based index of n?
Tavas is not as smart as SaDDas, so he asked you to do him a favor and solve this problem so he can have his headphones back.
Input
The first and only line of input contains a lucky number n (1 β€ n β€ 109).
Output
Print the index of n among all lucky numbers.
Examples
Input
4
Output
1
Input
7
Output
2
Input
77
Output
6
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int sol = 0, t;
string n;
cin >> n;
t = n.size();
for (int k = 0; k < t; k++) {
if (n[k] == '7') sol = sol + 2 * pow(2, t - 1 - k);
if (n[k] == '4') sol = sol + pow(2, t - 1 - k);
}
cout << sol << endl;
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
The problem uses a simplified TCP/IP address model, please make sure you've read the statement attentively.
Polycarpus has found a job, he is a system administrator. One day he came across n IP addresses. Each IP address is a 32 bit number, represented as a group of four 8-bit numbers (without leading zeroes), separated by dots. For example, the record 0.255.1.123 shows a correct IP address and records 0.256.1.123 and 0.255.1.01 do not. In this problem an arbitrary group of four 8-bit numbers is a correct IP address.
Having worked as an administrator for some time, Polycarpus learned that if you know the IP address, you can use the subnet mask to get the address of the network that has this IP addess.
The subnet mask is an IP address that has the following property: if we write this IP address as a 32 bit string, that it is representable as "11...11000..000". In other words, the subnet mask first has one or more one bits, and then one or more zero bits (overall there are 32 bits). For example, the IP address 2.0.0.0 is not a correct subnet mask as its 32-bit record looks as 00000010000000000000000000000000.
To get the network address of the IP address, you need to perform the operation of the bitwise "and" of the IP address and the subnet mask. For example, if the subnet mask is 255.192.0.0, and the IP address is 192.168.1.2, then the network address equals 192.128.0.0. In the bitwise "and" the result has a bit that equals 1 if and only if both operands have corresponding bits equal to one.
Now Polycarpus wants to find all networks to which his IP addresses belong. Unfortunately, Polycarpus lost subnet mask. Fortunately, Polycarpus remembers that his IP addresses belonged to exactly k distinct networks. Help Polycarpus find the subnet mask, such that his IP addresses will belong to exactly k distinct networks. If there are several such subnet masks, find the one whose bit record contains the least number of ones. If such subnet mask do not exist, say so.
Input
The first line contains two integers, n and k (1 β€ k β€ n β€ 105) β the number of IP addresses and networks. The next n lines contain the IP addresses. It is guaranteed that all IP addresses are distinct.
Output
In a single line print the IP address of the subnet mask in the format that is described in the statement, if the required subnet mask exists. Otherwise, print -1.
Examples
Input
5 3
0.0.0.1
0.1.1.2
0.0.2.1
0.1.1.0
0.0.2.3
Output
255.255.254.0
Input
5 2
0.0.0.1
0.1.1.2
0.0.2.1
0.1.1.0
0.0.2.3
Output
255.255.0.0
Input
2 1
255.0.0.1
0.0.0.2
Output
-1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
unsigned int mas[100100];
int main() {
int i, j, k, m, n;
scanf("%d %d", &n, &k);
for (i = 0; i < n; i++) {
unsigned int a, b, c, d;
scanf("%u.%u.%u.%u", &a, &b, &c, &d);
mas[i] = (a << 24) + (b << 16) + (c << 8) + d;
}
unsigned int mask = 1u << 31;
while (!(mask & 1)) {
set<unsigned int> nets;
for (i = 0; i < n; i++) {
nets.insert(mas[i] & mask);
}
if (nets.size() == k) break;
mask >>= 1u;
mask |= 1u << 31;
}
if (mask & 1)
printf("-1");
else
printf("%u.%u.%u.%u", mask >> 24, (mask >> 16) & 0xff, (mask >> 8) & 0xff,
mask & 0xff);
return 0;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
Once upon a time a little frog whose name was Vasya decided to travel around his home swamp. Overall there are n mounds on the swamp, located on one line. The distance between the neighboring mounds is one meter. Vasya wants to visit all the mounds in one day; besides, he wants to visit each one exactly once. For that he makes a route plan, to decide the order in which to jump on the mounds. Vasya can pick any mound as the first one. He thinks it boring to jump two times at the same distance. That's why he wants any two jumps on his route to have different lengths. Help Vasya the Frog and make the plan for him.
Input
The single line contains a number n (1 β€ n β€ 104) which is the number of mounds.
Output
Print n integers pi (1 β€ pi β€ n) which are the frog's route plan.
* All the pi's should be mutually different.
* All the |piβpi + 1|'s should be mutually different (1 β€ i β€ n - 1).
If there are several solutions, output any.
Examples
Input
2
Output
1 2
Input
3
Output
1 3 2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using namespace std;
int32_t main() {
long long n;
cin >> n;
for (long long i = 1; i <= (n / 2); ++i) {
cout << i << " " << (n - i + 1) << " ";
}
if (n & 1) cout << ((n + 1) / 2);
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
Unknown pathogen
Dr. Hideyo discovered an unknown pathogen. This pathogen has a chain structure in which two types of bacteria called Akdamakin and Zendamakin are linked in a straight line. We want to detoxify this pathogen for humankind.
It is known that this pathogen weakens when the length is 2 or less and is detoxified by immunity. Dr. Hideyo can cut this pathogen anywhere to make two chains, the first half and the second half. You can also connect two chains into one chain.
However, it should be noted that chains with a large number of Akdamakin are extremely harmful. When the number of Akdamakins in a chain exceeds the number of Zendamakins, the Akdamakins begin to grow indefinitely at that moment. This is no exception for chains with a length of 2 or less, so you must carefully cut the chains.
Is it possible to make one chain harmless by making it 2 or less in length without making a chain that has more Akdamakins at any moment? Dr. Hideyo has instructed you, your assistant, to write a program to determine if detoxification is possible. Create a program that outputs the operation if detoxification is possible, and outputs that it is impossible if it is not possible. However, the number of steps for that operation does not have to be minimal.
Input / output example
Input example
6
oooxxxx
ooooxxx
oxxooxxo
ooxx
oo
ooo
Output example
-1
7
split 0 0
join 2 1
split 3 4
split 4 0
join 7 6
split 8 2
split 9 0
3
split 0 1
split 2 1
split 4 1
-1
0
1
split 0 0
For example, the second pathogen ooooxxx in the input example
split 0 0 creates o (1) and oooxxx (2). Here, the numbers in parentheses represent identification numbers.
join 2 1 creates oooxxxo (3) and 1 and 2 disappear.
split 3 4 gives oooxx (4) and xo (5). At this time, there is a chain of {oooxx (4), xo (5)}.
split 40 produces o (6) and ooxx (7). {xo (5), o (6), ooxx (7)}
ooxxo (8) can be created by join 7 6. {xo (5), ooxxo (8)}
split 8 2 produces oox (9) and xo (10). {xo (5), oox (9), xo (10)}
The split 90 results in {xo (5), xo (10), o (11), ox (12)} and ends.
input
The input is given in the following format.
Q
str1
str2
::
strQ
The number of pathogens Q (1 β€ Q β€ 300) is given on the first line. The following Q line is given a single string stri consisting of'o'(Zendamakin) and'x' (Akudamakin) representing the initial state of each pathogen. The length of the string stri is 1 or more and 100 or less.
output
For stri, if there is a column of disconnect / join operations that meets the requirements, the first row of output outputs an integer n representing the length of the operation column, and the following n rows contain the operation content 1 per row. Outputs each operation in order from the first operation.
The disconnect operation should be expressed in the following format.
split a p
a is an integer representing the identification number of the chain to be cut, and p is the position to cut the chain. As a result of this operation, chain a is cleaved immediately after the p-th (serial number starting with 0) fungus from the beginning. Of the two new chains, the first half is given the identification number m + 1 and the second half is given the identification number m + 2 (where m represents the highest identification number ever assigned. ). Also, the chain a disappears.
The join operation should be expressed in the following format.
join a b
a and b are integers representing the identification numbers of the chains to be joined. The result of this operation is a new chain with the beginning of chain b joined to the end of chain a. The newly created strand is given the identification number m + 1 (where m represents the highest identification number ever given). Also, the chains a and b disappear.
The first strand given as input is given the identification number 0.
As a result of the operation, if the chain is disassembled to meet the requirements of the problem, any operation is judged to be the correct answer. The length of the operation sequence does not necessarily have to be the shortest. However, the length of the operation sequence must be 20000 or less. Whenever a chain is decomposable in a dataset, it is guaranteed that there is an operating sequence that meets this condition.
If an invalid operation sequence is output, it is judged as an incorrect answer. The illegal operation sequence includes the following cases.
* If 0 β€ p <(length of chain a) -1 is not satisfied in the split operation split a p.
* When the identification number of the chain to be the target of the cutting / joining operation has not been generated yet, or when it has disappeared because it has already been the target of another operation.
* In the join operation join a b, if a and b are equal.
If there is no disconnect / join operation column that satisfies the request, "-1" is output.
Example
Input
6
oooxxxx
ooooxxx
oxxooxxo
ooxx
oo
ooo
Output
-1
7
split 0 0
join 2 1
split 3 4
split 4 0
join 7 6
split 8 2
split 9 0
3
split 0 1
split 2 1
split 4 1
-1
0
1
split 0 0
### Response
```cpp
#define _USE_MATH_DEFINES
#include <cstdio>
#include <iostream>
#include <sstream>
#include <fstream>
#include <iomanip>
#include <algorithm>
#include <cmath>
#include <complex>
#include <string>
#include <vector>
#include <list>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <bitset>
#include <numeric>
#include <limits>
#include <climits>
#include <cfloat>
#include <functional>
#include <iterator>
using namespace std;
string makeCommand(string s, int a, int b)
{
ostringstream oss;
oss << s << ' ' << a << ' ' << b;
return oss.str();
}
bool solve(string s, vector<string>& ans)
{
int n = s.size();
ans.clear();
int oNum = count(s.begin(), s.end(), 'o');
int xNum = s.size() - oNum;
if(oNum < xNum){
return false;
}
else if(oNum == xNum){
bool ng = false;
for(int i=0; i<n; i+=2){
if(s[i] == s[i+1])
ng = true;
}
if(ng)
return false;
}
int index = 0;
while(n > 2){
if(s.find('x') == string::npos){
ans.push_back(makeCommand("split", index, 1));
index += 2;
s = s.substr(2);
n -= 2;
}
else if(s[0] != s[1]){
ans.push_back(makeCommand("split", index, 1));
index += 2;
s = s.substr(2);
n -= 2;
}
else if(s[n-2] != s[n-1]){
ans.push_back(makeCommand("split", index, n - 3));
index += 2;
s = s.substr(0, n - 2);
n -= 2;
}
else{
int cnt1 = 0;
int cnt2 = n - count(s.begin(), s.end(), 'x') * 2;
for(int i=0; ; ++i){
if(s[i] == 'o'){
++ cnt1;
-- cnt2;
}
else{
-- cnt1;
++ cnt2;
}
if(cnt1 >= 0 && cnt2 >= 0){
ans.push_back(makeCommand("split", index, i));
ans.push_back(makeCommand("join", index + 2, index + 1));
s = s.substr(i+1) + s.substr(0, i+1);
break;
}
}
index += 3;
}
}
return true;
}
int main()
{
int q;
cin >> q;
while(--q >= 0){
string s;
cin >> s;
vector<string> ans;
if(solve(s, ans)){
cout << ans.size() << endl;
for(const string& t : ans)
cout << t << endl;
}
else{
cout << -1 << endl;
}
}
return 0;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
From tomorrow, the long-awaited summer vacation will begin. So I decided to invite my friends to go out to the sea.
However, many of my friends are shy. They would hate it if they knew that too many people would come with them.
Besides, many of my friends want to stand out. They will probably hate it if they know that not many people come with them.
Also, some of my friends are always shy, though they always want to stand out. They will surely hate if too many or too few people come with them.
This kind of thing should be more fun to do in large numbers. That's why I want to invite as many friends as possible. However, it is not good to force a friend you dislike.
How many friends can I invite up to?
I'm not very good at this kind of problem that seems to use my head. So I have a request for you. If you don't mind, could you solve this problem for me? No, I'm not overdoing it. But if I'm slacking off, I'm very happy.
Input
N
a1 b1
a2 b2
..
..
..
aN bN
The integer N (1 β€ N β€ 100,000) is written on the first line of the input. This represents the number of friends.
On the following N lines, the integer ai and the integer bi (2 β€ ai β€ bi β€ 100,001) are written separated by blanks. The integers ai and bi written on the 1 + i line indicate that the i-th friend does not want to go to the sea unless the number of people going to the sea is ai or more and bi or less. Note that the number of people going to the sea includes "I".
Output
Output the maximum number of friends you can invite to the sea so that no friends dislike it.
Examples
Input
4
2 5
4 7
2 4
3 6
Output
3
Input
5
8 100001
7 100001
12 100001
8 100001
3 100001
Output
0
Input
6
2 9
4 8
6 7
6 6
5 7
2 100001
Output
5
### Response
```cpp
#include <iostream>
using namespace std;
#define MAX 100002
int main() {
int n;
int a, b;
int v[MAX] = {};
cin >> n;
for(int i=0; i<n; i++) {
cin >> a >> b;
v[a] ++;
v[b+1] --;
}
int now = 0;
int ans = 0;
for(int i=0; i<MAX; i++) {
now += v[i];
if(i <= now+1) ans = i-1;
}
cout << ans << endl;
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
The only difference between easy and hard versions is the length of the string.
You are given a string s and a string t, both consisting only of lowercase Latin letters. It is guaranteed that t can be obtained from s by removing some (possibly, zero) number of characters (not necessary contiguous) from s without changing order of remaining characters (in other words, it is guaranteed that t is a subsequence of s).
For example, the strings "test", "tst", "tt", "et" and "" are subsequences of the string "test". But the strings "tset", "se", "contest" are not subsequences of the string "test".
You want to remove some substring (contiguous subsequence) from s of maximum possible length such that after removing this substring t will remain a subsequence of s.
If you want to remove the substring s[l;r] then the string s will be transformed to s_1 s_2 ... s_{l-1} s_{r+1} s_{r+2} ... s_{|s|-1} s_{|s|} (where |s| is the length of s).
Your task is to find the maximum possible length of the substring you can remove so that t is still a subsequence of s.
Input
The first line of the input contains one string s consisting of at least 1 and at most 200 lowercase Latin letters.
The second line of the input contains one string t consisting of at least 1 and at most 200 lowercase Latin letters.
It is guaranteed that t is a subsequence of s.
Output
Print one integer β the maximum possible length of the substring you can remove so that t is still a subsequence of s.
Examples
Input
bbaba
bb
Output
3
Input
baaba
ab
Output
2
Input
abcde
abcde
Output
0
Input
asdfasdf
fasd
Output
3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int minPrefix[200000 + 3], maxSuffix[200000 + 3], answer;
string s, t;
int main() {
cin >> s >> t;
int ptrS;
ptrS = 0;
for (int i = 0; i < t.length(); i++) {
while (s[ptrS] != t[i]) ptrS += 1;
minPrefix[i + 1] = ptrS + 1;
ptrS += 1;
}
ptrS = s.length() - 1;
for (int i = t.length() - 1; i >= 0; i--) {
while (s[ptrS] != t[i]) ptrS -= 1;
maxSuffix[i + 1] = ptrS + 1;
ptrS -= 1;
}
if (false) {
for (int i = 1; i <= t.length(); i++) {
cout << minPrefix[i] << " ";
}
cout << endl;
for (int i = 1; i <= t.length(); i++) {
cout << maxSuffix[i] << " ";
}
cout << endl;
}
answer = max((int)s.length() - minPrefix[t.length()], maxSuffix[1] - 1);
for (int i = 1; i < t.length(); i++) {
answer = max(answer, maxSuffix[i + 1] - minPrefix[i] - 1);
}
cout << answer << endl;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
J: City
Santa decides to deliver a present to a city.
The city has a rectangular shape divided into north-south $ H $ parcels x east-west $ W $ parcels, with one house delivering gifts to each parcel.
The $ X $ th section from the north and the $ Y $ th section from the west are represented by $ (X, Y) $.
Santa moves under the following conditions.
* First, get off at block $ (S, T) $ and start from this place.
* You can move to the adjacent sections in the north, south, east, and west with one move, and you cannot move outside the city.
* You will never enter the area you visited once.
Determine if Santa can visit all the houses in the city.
input
$ H, W, S, T $ are given separated by blanks.
output
Output "Yes" if Santa can visit all the homes in the city, otherwise output "No".
Constraint
* $ H, W $ are integers greater than or equal to $ 2 $ and less than or equal to $ 1 \ 000 \ 000 \ 000 $
* $ S $ is an integer greater than or equal to $ 1 $ and less than or equal to $ H $
* $ T $ is an integer greater than or equal to $ 1 $ and less than or equal to $ W $
Input example 1
4 5 2 3
Output example 1
Yes
For example, you can go to the figure.
<image>
Input example 2
3 3 1 2
Output example 2
No
Example
Input
4 5 2 3
Output
Yes
### Response
```cpp
#include<cstdio>
#include<functional>
#include<algorithm>
using namespace std;
int main(void)
{
int h,w,s,t,flg;
scanf("%d %d %d %d",&h,&w,&s,&t);
flg=1;
if((s-1)%2==0 && (h-s)%2==0) {
if((t-1)%2==1 && (w-t)%2==1) flg=0;
}
if((t-1)%2==0 && (w-t)%2==0) {
if((s-1)%2==1 && (h-s)%2==1) flg=0;
}
if(flg==1) printf("Yes\n");
else printf("No\n");
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
Good job! Now that Heidi is able to distinguish between Poisson and uniform distributions, she is in a good position to actually estimate the populations.
Can you help Heidi estimate each village's population?
Input
Same as the easy version.
Output
Output one line per village, in the same order as provided in the input, containing your (integer) population estimate.
Your answer is considered correct if it is an integer that falls into the interval <image>, where P is the real population of the village, used to create the distribution (either Poisson or uniform) from which the marmots drew their answers.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 10005;
int n, a[N];
int cnt[N];
int main() {
int T;
srand(time(0));
scanf("%d", &(T));
while (T--) {
memset(cnt, 0, sizeof(cnt));
double ex = 0;
for (int i = 1; i <= 250; i++)
scanf("%d", &(a[i])), cnt[a[i]]++, ex += a[i];
ex /= 250;
int tot = 0;
for (int i = 1; i <= ex / 3; i++) tot += cnt[i];
if (tot < 250 / 6 - 25) {
} else {
double dx = 0;
dx = 0;
for (int i = 1; i <= 250; i++) dx = max(dx, (double)a[i]);
dx /= 2.0;
ex = dx;
}
printf("%.0lf\n", ex);
}
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
Furik loves writing all sorts of problems, especially such that he can't solve himself. You've got one of his problems, the one Furik gave to Rubik. And Rubik asks you to solve it.
There is integer n and array a, consisting of ten integers, indexed by numbers from 0 to 9. Your task is to count the number of positive integers with the following properties:
* the number's length does not exceed n;
* the number doesn't have leading zeroes;
* digit i (0 β€ i β€ 9) occurs in the number at least a[i] times.
Input
The first line contains integer n (1 β€ n β€ 100). The next line contains 10 integers a[0], a[1], ..., a[9] (0 β€ a[i] β€ 100) β elements of array a. The numbers are separated by spaces.
Output
On a single line print the remainder of dividing the answer to the problem by 1000000007 (109 + 7).
Examples
Input
1
0 0 0 0 0 0 0 0 0 1
Output
1
Input
2
1 1 0 0 0 0 0 0 0 0
Output
1
Input
3
1 1 0 0 0 0 0 0 0 0
Output
36
Note
In the first sample number 9 meets the requirements.
In the second sample number 10 meets the requirements.
In the third sample numbers 10, 110, 210, 120, 103 meet the requirements. There are other suitable numbers, 36 in total.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
const int maxN = 110;
int a[maxN];
long long c[maxN][maxN], dp[maxN][maxN], ans;
void fillC() {
for (int i = 0; i < maxN; i++) c[i][i] = c[0][i] = 1;
for (int i = 1; i < maxN; i++)
for (int j = 1; j < maxN; j++)
c[i][j] = (c[i - 1][j - 1] + c[i][j - 1]) % MOD;
}
int main() {
int n;
fillC();
cin >> n;
for (int i = 0; i < 10; i++) cin >> a[i];
for (int i = a[9]; i <= n; i++) dp[i][9] = 1;
for (int i = 0; i <= n; i++)
for (int j = 8; j > 0; j--) {
long long now = 0;
for (int k = a[j]; k <= i; k++)
now = (now + dp[i - k][j + 1] * c[k][i]) % MOD;
dp[i][j] = now;
}
for (int i = 0; i <= n; i++) {
for (int j = a[0]; j <= i; j++)
dp[i][0] += (dp[i - j][1] * c[j][i - 1]) % MOD;
ans = ans + dp[i][0];
ans %= MOD;
}
cout << ans << endl;
cin >> n;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
Sean is trying to save a large file to a USB flash drive. He has n USB flash drives with capacities equal to a1, a2, ..., an megabytes. The file size is equal to m megabytes.
Find the minimum number of USB flash drives needed to write Sean's file, if he can split the file between drives.
Input
The first line contains positive integer n (1 β€ n β€ 100) β the number of USB flash drives.
The second line contains positive integer m (1 β€ m β€ 105) β the size of Sean's file.
Each of the next n lines contains positive integer ai (1 β€ ai β€ 1000) β the sizes of USB flash drives in megabytes.
It is guaranteed that the answer exists, i. e. the sum of all ai is not less than m.
Output
Print the minimum number of USB flash drives to write Sean's file, if he can split the file between drives.
Examples
Input
3
5
2
1
3
Output
2
Input
3
6
2
3
2
Output
3
Input
2
5
5
10
Output
1
Note
In the first example Sean needs only two USB flash drives β the first and the third.
In the second example Sean needs all three USB flash drives.
In the third example Sean needs only one USB flash drive and he can use any available USB flash drive β the first or the second.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int i, j = 0, a[n];
for (i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (i = n - 1; i >= 0; i--) {
m = m - a[i];
j++;
if (m <= 0) {
cout << j;
return 0;
}
}
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
You are given $n$ integers $w_i (i = 0, 1, ..., n-1)$ to be sorted in ascending order. You can swap two integers $w_i$ and $w_j$. Each swap operation has a cost, which is the sum of the two integers $w_i + w_j$. You can perform the operations any number of times.
Write a program which reports the minimal total cost to sort the given integers.
Constraints
* $1 \leq n \leq 1,000$
* $0 \leq w_i\leq 10^4$
* $w_i$ are all different
Input
In the first line, an integer $n$ is given. In the second line, $n$ integers $w_i (i = 0, 1, 2, ... n-1)$ separated by space characters are given.
Output
Print the minimal cost in a line.
Examples
Input
5
1 5 3 4 2
Output
7
Input
4
4 3 2 1
Output
10
### Response
```cpp
#include <vector>
#include <map>
#include <algorithm>
#include <cstdio>
using namespace std;
int do_cycle(vector<int> &v,int x){
int s=0,m=1<<30;
for(auto &e:v)s+=e,m=min(m,e);
return min(s+(v.size()-2)*m,s+m+(v.size()+1)*x);
}
int main(){
int N,x=1<<30,r=0;
scanf("%d",&N);
vector<int>v(N),b(N),se(N);
map<int,int>m;
vector<vector<int> >cycles;
for(int i=0;i<N;i++)scanf("%d",&v[i]),x=min(x,v[i]),se[i]=v[i];
sort(se.begin(),se.end());
int i=0;for(auto &e:se){m[e]=i++;}
for(int i=0;i<N;i++)if(!b[i]){
vector<int>cycle;
int k=i;
do{
cycle.push_back(se[k]);
b[k]=1;
k=m[v[k]];
}while(k!=i);
r+=do_cycle(cycle,x);
}
printf("%d\n",r);
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
Iahub is playing an uncommon game. Initially, he has n boxes, numbered 1, 2, 3, ..., n. Each box has some number of candies in it, described by a sequence a1, a2, ..., an. The number ak represents the number of candies in box k.
The goal of the game is to move all candies into exactly two boxes. The rest of n - 2 boxes must contain zero candies. Iahub is allowed to do several (possible zero) moves. At each move he chooses two different boxes i and j, such that ai β€ aj. Then, Iahub moves from box j to box i exactly ai candies. Obviously, when two boxes have equal number of candies, box number j becomes empty.
Your task is to give him a set of moves such as Iahub to archive the goal of the game. If Iahub can't win the game for the given configuration of boxes, output -1. Please note that in case there exist a solution, you don't need to print the solution using minimal number of moves.
Input
The first line of the input contains integer n (3 β€ n β€ 1000). The next line contains n non-negative integers: a1, a2, ..., an β sequence elements. It is guaranteed that sum of all numbers in sequence a is up to 106.
Output
In case there exists no solution, output -1. Otherwise, in the first line output integer c (0 β€ c β€ 106), representing number of moves in your solution. Each of the next c lines should contain two integers i and j (1 β€ i, j β€ n, i β j): integers i, j in the kth line mean that at the k-th move you will move candies from the j-th box to the i-th one.
Examples
Input
3
3 6 9
Output
2
2 3
1 3
Input
3
0 1 0
Output
-1
Input
4
0 1 1 0
Output
0
Note
For the first sample, after the first move the boxes will contain 3, 12 and 3 candies. After the second move, the boxes will contain 6, 12 and 0 candies. Now all candies are in exactly 2 boxes.
For the second sample, you can observe that the given configuration is not valid, as all candies are in a single box and they should be in two boxes. Also, any move won't change the configuration, so there exists no solution.
For the third sample, all candies are already in 2 boxes. Hence, no move is needed.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
struct _two {
int a, b;
} ans[N * N], x, y, z;
bool operator<(_two x, _two y) { return x.a < y.a; }
int n, tot;
int a[N];
void Init() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
}
void Sort() {
if (z < x) swap(x, z);
if (y < x) swap(x, y);
if (z < y) swap(y, z);
}
void Change() {
while (1) {
Sort();
if (!x.a) break;
int temp = y.a / x.a;
for (int i = 0; i <= 20; i++) {
if (1 << i > temp) break;
if (temp & 1 << i) {
ans[++tot] = (_two){x.b, y.b};
y.a -= x.a;
} else {
ans[++tot] = (_two){x.b, z.b};
z.a -= x.a;
}
x.a += x.a;
}
}
}
void Work() {
int num = 0;
for (int i = 1; i <= n; i++)
if (a[i]) num++;
if (num < 2)
puts("-1");
else {
num = tot = 0;
for (int i = 1; i <= n; i++)
if (a[i]) {
++num;
if (num == 1) z = (_two){a[i], i};
if (num == 2) y = (_two){a[i], i};
if (num > 2) {
x = (_two){a[i], i};
Change();
}
}
printf("%d\n", tot);
for (int i = 1; i <= tot; i++) printf("%d %d\n", ans[i].a, ans[i].b);
}
}
int main() {
Init();
Work();
return 0;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
There are n children in Jzzhu's school. Jzzhu is going to give some candies to them. Let's number all the children from 1 to n. The i-th child wants to get at least ai candies.
Jzzhu asks children to line up. Initially, the i-th child stands at the i-th place of the line. Then Jzzhu start distribution of the candies. He follows the algorithm:
1. Give m candies to the first child of the line.
2. If this child still haven't got enough candies, then the child goes to the end of the line, else the child go home.
3. Repeat the first two steps while the line is not empty.
Consider all the children in the order they go home. Jzzhu wants to know, which child will be the last in this order?
Input
The first line contains two integers n, m (1 β€ n β€ 100; 1 β€ m β€ 100). The second line contains n integers a1, a2, ..., an (1 β€ ai β€ 100).
Output
Output a single integer, representing the number of the last child.
Examples
Input
5 2
1 3 1 4 2
Output
4
Input
6 4
1 1 2 2 3 3
Output
6
Note
Let's consider the first sample.
Firstly child 1 gets 2 candies and go home. Then child 2 gets 2 candies and go to the end of the line. Currently the line looks like [3, 4, 5, 2] (indices of the children in order of the line). Then child 3 gets 2 candies and go home, and then child 4 gets 2 candies and goes to the end of the line. Currently the line looks like [5, 2, 4]. Then child 5 gets 2 candies and goes home. Then child 2 gets two candies and goes home, and finally child 4 gets 2 candies and goes home.
Child 4 is the last one who goes home.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long int n, m;
cin >> n >> m;
vector<pair<long long int, long long int> > v;
long long int i = 1;
while (n--) {
long long int x;
cin >> x;
if (x % m == 0) {
v.push_back({(x / m), i});
} else
v.push_back({(x / m) + 1, i});
i++;
}
sort(v.begin(), v.end());
cout << (v[v.size() - 1].second);
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
Polycarp is currently developing a project in Vaja language and using a popular dependency management system called Vamen. From Vamen's point of view both Vaja project and libraries are treated projects for simplicity.
A project in Vaja has its own uniqie non-empty name consisting of lowercase latin letters with length not exceeding 10 and version β positive integer from 1 to 106. Each project (keep in mind that it is determined by both its name and version) might depend on other projects. For sure, there are no cyclic dependencies.
You're given a list of project descriptions. The first of the given projects is the one being developed by Polycarp at this moment. Help Polycarp determine all projects that his project depends on (directly or via a certain chain).
It's possible that Polycarp's project depends on two different versions of some project. In this case collision resolving is applied, i.e. for each such project the system chooses the version that minimizes the distance from it to Polycarp's project. If there are several options, the newer (with the maximum version) is preferred. This version is considered actual; other versions and their dependencies are ignored.
More formal, choose such a set of projects of minimum possible size that the following conditions hold:
* Polycarp's project is chosen;
* Polycarp's project depends (directly or indirectly) on all other projects in the set;
* no two projects share the name;
* for each project x that some other project in the set depends on we have either x or some y with other version and shorter chain to Polycarp's project chosen. In case of ties the newer one is chosen.
Output all Polycarp's project's dependencies (Polycarp's project itself should't be printed) in lexicographical order.
Input
The first line contains an only integer n (1 β€ n β€ 1 000) β the number of projects in Vaja.
The following lines contain the project descriptions. Each project is described by a line consisting of its name and version separated by space. The next line gives the number of direct dependencies (from 0 to n - 1) and the dependencies themselves (one in a line) in arbitrary order. Each dependency is specified by its name and version. The projects are also given in arbitrary order, but the first of them is always Polycarp's. Project descriptions are separated by one empty line. Refer to samples for better understanding.
It's guaranteed that there are no cyclic dependencies.
Output
Output all Polycarp's project's dependencies in lexicographical order.
Examples
Input
4
a 3
2
b 1
c 1
Β
b 2
0
Β
b 1
1
b 2
Β
c 1
1
b 2
Output
2
b 1
c 1
Input
9
codehorses 5
3
webfrmk 6
mashadb 1
mashadb 2
Β
commons 2
0
Β
mashadb 3
0
Β
webfrmk 6
2
mashadb 3
commons 2
Β
extra 4
1
extra 3
Β
extra 3
0
Β
extra 1
0
Β
mashadb 1
1
extra 3
Β
mashadb 2
1
extra 1
Output
4
commons 2
extra 1
mashadb 2
webfrmk 6
Input
3
abc 1
2
abc 3
cba 2
abc 3
0
cba 2
0
Output
1
cba 2
Note
The first sample is given in the pic below. Arrow from A to B means that B directly depends on A. Projects that Polycarp's project Β«aΒ» (version 3) depends on are painted black.
<image>
The second sample is again given in the pic below. Arrow from A to B means that B directly depends on A. Projects that Polycarp's project Β«codehorsesΒ» (version 5) depends on are paint it black. Note that Β«extra 1Β» is chosen instead of Β«extra 3Β» since Β«mashadb 1Β» and all of its dependencies are ignored due to Β«mashadb 2Β».
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
struct P {
string s;
int v;
};
bool operator<(P a, P b) {
if (a.s == b.s) return a.v < b.v;
return a.s < b.s;
}
int n;
P s;
map<P, vector<P>> g;
set<string> usd;
vector<P> q;
map<string, P> mp;
vector<P> ans;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
P u;
cin >> u.s >> u.v;
if (i == 0) s = u;
int k;
cin >> k;
while (k--) {
P v;
cin >> v.s >> v.v;
g[u].push_back(v);
}
}
q.push_back(s);
usd.insert(s.s);
while (!q.empty()) {
mp.clear();
for (P u : q) {
for (P v : g[u]) {
if (usd.count(v.s)) continue;
if (mp[v.s].v < v.v) mp[v.s] = v;
}
}
q.clear();
for (auto p : mp) {
P u = p.second;
q.push_back(u);
usd.insert(u.s);
ans.push_back(u);
}
}
sort(ans.begin(), ans.end());
cout << ans.size() << "\n";
for (P p : ans) cout << p.s << " " << p.v << "\n";
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
Cthulhu decided to catch Scaygerboss. Scaygerboss found it out and is trying to hide in a pack of his scaygers. Each scayger except Scaygerboss is either a male or a female. Scaygerboss's gender is "other".
Scaygers are scattered on a two-dimensional map divided into cells. A scayger looks nerdy and loveable if it is staying in the same cell with exactly one scayger of a gender that is different from its own gender. Cthulhu will not be able to catch Scaygerboss if all the scaygers on the map look nerdy and loveable.
The scaygers can move around at different speeds. For each scayger, we are given the time it takes this scayger to move from a cell to an adjacent cell. Cells are adjacent if they share a common side. At any point of time, each cell that does not contain an obstacle can be occupied by an arbitrary number of scaygers. Scaygers cannot move to cells with obstacles.
Calculate minimal time in order to make all scaygers look nerdy and loveable if they move optimally toward this goal.
Input
The first line contains 4 integers: n, m, males, females (0 β€ males, females β€ nΒ·m). n and m are dimensions of the map; males and females are numbers of male scaygers and female scaygers.
Next n lines describe the map. Each of these lines contains m characters. Character '.' stands for a free cell; character '#' stands for a cell with an obstacle.
The next line contains 3 integers r, c, and t (1 β€ r β€ n, 1 β€ c β€ m, 1 β€ t β€ 109): the current coordinates of Scaygerboss and the time it takes Scaygerboss to move to an adjacent cell. The next males lines contain coordinates and times of male scaygers in the same format as for Scaygerboss. The next females lines contain coordinates and times of female scaygers in the same format as for Scaygerboss. (The coordinates and times adhere to the same limits as for Scaygerboss.) All scaygers reside in cells without obstacles.
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 F1 (14 points), the constraints 1 β€ n, m β€ 11 will hold.
* In subproblem F2 (6 points), the constraints 1 β€ n, m β€ 22 will hold.
Output
Output the minimum possible time it takes to make all scaygers look nerdy and loveable or -1 if it is impossible.
Examples
Input
4 4 2 3
....
.###
####
####
2 1 1
2 1 2
2 1 2
2 1 2
2 1 2
1 1 2
Output
2
Input
2 4 2 2
....
.###
2 1 1
2 1 2
2 1 2
2 1 2
2 1 2
Output
-1
Note
Consider the first sample test. The scaygers are hiding on a 4 by 4 map. Scaygerboss initially resides in the cell (2, 1) and can move between cells in 1 unit of time. There are also 2 male and 3 female scaygers on the map. One of the females initially is in the cell (1, 1), and all the other scaygers are in the cell (2, 1). All the scaygers move between cells in 2 units of time. If Scaygerboss and the female scayger from the cell (1, 1) move to the cell (1, 2), and a male and a female scayger from those residing in the cell (2, 1) move to the cell (1, 1), then all the scaygers will look nerdy and lovable in 2 units of time.
### Response
```cpp
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
const int INF = 1000000000;
class MaximumFlow {
int s, f;
public:
struct edge {
int u, v;
int capacity, flow;
edge() { u = v = capacity = flow = 0; }
edge(int u_, int v_, int capacity_, int flow_)
: u(u_), v(v_), capacity(capacity_), flow(flow_) {}
};
vector<edge> edges;
vector<vector<int> > graph;
vector<int> ptr, level;
queue<int> q;
int n;
MaximumFlow() {}
MaximumFlow(int number) {
n = number;
graph.resize(n);
ptr.assign(n, 0);
level.resize(n);
}
void addEdge(int u, int v, int capacity) {
int sz = (int)(edges.size());
edges.push_back(edge(u, v, capacity, 0));
edges.push_back(edge(v, u, 0, 0));
graph[u].push_back(sz);
graph[v].push_back(sz + 1);
}
void updateLevels() {
level.assign(n, -1);
q.push(s);
level[s] = 0;
while (!q.empty()) {
int topq = q.front();
q.pop();
for (int index = 0; index < graph[topq].size(); ++index) {
int i = graph[topq][index];
int to = edges[i].v;
if (edges[i].capacity - edges[i].flow == 0) {
continue;
}
if (level[to] == -1) {
level[to] = level[topq] + 1;
q.push(to);
}
}
}
}
int pushFlow(int v, int flow) {
if (v == f || flow == 0) {
return flow;
}
for (; ptr[v] < graph[v].size(); ++ptr[v]) {
int index = graph[v][ptr[v]];
int to = edges[index].v;
if (level[v] + 1 == level[to]) {
int pushed =
pushFlow(to, min(flow, edges[index].capacity - edges[index].flow));
if (pushed > 0) {
edges[index].flow += pushed;
edges[index ^ 1].flow -= pushed;
return pushed;
}
}
}
return 0;
}
int dinicFlow(int start, int finish) {
s = start, f = finish;
int result = 0;
while (true) {
updateLevels();
if (level[f] == -1) {
break;
}
while (true) {
int pushed = pushFlow(start, INF);
if (pushed == 0) {
break;
}
result += pushed;
}
ptr.assign(n, 0);
}
return result;
}
};
const int maxN = 25;
int n, m, male, female;
string s[maxN];
int r[2 * maxN * maxN], c[2 * maxN * maxN], t[2 * maxN * maxN];
int d[maxN][maxN][maxN][maxN];
int dx[] = {-1, 0, 0, 1};
int dy[] = {0, -1, 1, 0};
bool isValid(int x, int y) {
return 0 <= x && x < n && 0 <= y && y < m && s[x][y] == '.';
}
void calc(int d[maxN][maxN], int u, int v) {
memset(d, -1, sizeof(d));
d[u][v] = 0;
queue<pair<int, int> > q;
q.push(make_pair(u, v));
while (!q.empty()) {
pair<int, int> p = q.front();
q.pop();
int x = p.first;
int y = p.second;
for (int i = 0; i < 4; ++i) {
if (isValid(x + dx[i], y + dy[i]) && d[x + dx[i]][y + dy[i]] == -1) {
d[x + dx[i]][y + dy[i]] = d[x][y] + 1;
q.push(make_pair(x + dx[i], y + dy[i]));
}
}
}
}
bool check(long long value) {
{
MaximumFlow F(male + female + 1 + 2 * n * m + 2);
int start = male + female + 1 + 2 * n * m;
int finish = start + 1;
for (int i = (male < female ? 0 : 1); i <= male; ++i) {
for (int x = 0; x < n; ++x) {
for (int y = 0; y < m; ++y) {
if (d[r[i]][c[i]][x][y] == -1) {
continue;
}
if ((long long)(d[r[i]][c[i]][x][y]) * (long long)(t[i]) <= value) {
F.addEdge(i, male + female + 1 + x * m + y, 1);
}
}
}
F.addEdge(start, i, 1);
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (isValid(i, j)) {
F.addEdge(male + female + 1 + i * m + j,
male + female + 1 + n * m + i * m + j, 1);
}
}
}
for (int i = 0; i <= male + female; ++i) {
if (i < male + 1) {
if (female < male && i == 0) {
} else {
continue;
}
}
for (int x = 0; x < n; ++x) {
for (int y = 0; y < m; ++y) {
if (d[r[i]][c[i]][x][y] == -1) {
continue;
}
if ((long long)(d[r[i]][c[i]][x][y]) * (long long)(t[i]) <= value) {
F.addEdge(male + female + 1 + n * m + x * m + y, i, 1);
}
}
}
F.addEdge(i, finish, 1);
}
return F.dinicFlow(start, finish) == (male + female + 1) / 2;
}
}
int main() {
cin >> n >> m >> male >> female;
for (int i = 0; i < n; ++i) {
cin >> s[i];
}
cin >> r[0] >> c[0] >> t[0];
--r[0];
--c[0];
for (int i = 1; i <= male; ++i) {
cin >> r[i] >> c[i] >> t[i];
--r[i];
--c[i];
}
for (int i = male + 1; i <= male + female; ++i) {
cin >> r[i] >> c[i] >> t[i];
--r[i];
--c[i];
}
memset(d, -1, sizeof(d));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (isValid(i, j)) {
calc(d[i][j], i, j);
}
}
}
if (male + 1 != female && male != female + 1) {
cout << -1 << endl;
return 0;
}
long long left_bound = 0, right_bound = 1000000000000000000LL;
if (!check(right_bound)) {
cout << -1 << endl;
return 0;
}
while (right_bound - left_bound > 1) {
long long middle = (left_bound + right_bound) / 2;
if (check(middle)) {
right_bound = middle;
} else {
left_bound = middle;
}
}
if (check(left_bound)) {
cout << left_bound << endl;
} else {
cout << right_bound << endl;
}
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
Denis was very sad after Nastya rejected him. So he decided to walk through the gateways to have some fun. And luck smiled at him! When he entered the first courtyard, he met a strange man who was selling something.
Denis bought a mysterious item and it was... Random permutation generator! Denis could not believed his luck.
When he arrived home, he began to study how his generator works and learned the algorithm. The process of generating a permutation consists of n steps. At the i-th step, a place is chosen for the number i (1 β€ i β€ n). The position for the number i is defined as follows:
* For all j from 1 to n, we calculate r_j β the minimum index such that j β€ r_j β€ n, and the position r_j is not yet occupied in the permutation. If there are no such positions, then we assume that the value of r_j is not defined.
* For all t from 1 to n, we calculate count_t β the number of positions 1 β€ j β€ n such that r_j is defined and r_j = t.
* Consider the positions that are still not occupied by permutation and among those we consider the positions for which the value in the count array is maximum.
* The generator selects one of these positions for the number i. The generator can choose any position.
Let's have a look at the operation of the algorithm in the following example:
<image>
Let n = 5 and the algorithm has already arranged the numbers 1, 2, 3 in the permutation. Consider how the generator will choose a position for the number 4:
* The values of r will be r = [3, 3, 3, 4, Γ], where Γ means an indefinite value.
* Then the count values will be count = [0, 0, 3, 1, 0].
* There are only two unoccupied positions in the permutation: 3 and 4. The value in the count array for position 3 is 3, for position 4 it is 1.
* The maximum value is reached only for position 3, so the algorithm will uniquely select this position for number 4.
Satisfied with his purchase, Denis went home. For several days without a break, he generated permutations. He believes that he can come up with random permutations no worse than a generator. After that, he wrote out the first permutation that came to mind p_1, p_2, β¦, p_n and decided to find out if it could be obtained as a result of the generator.
Unfortunately, this task was too difficult for him, and he asked you for help. It is necessary to define whether the written permutation could be obtained using the described algorithm if the generator always selects the position Denis needs.
Input
The first line contains a single integer t (1 β€ t β€ 10^5) β the number of test cases. Then the descriptions of the test cases follow.
The first line of the test case contains a single integer n (1 β€ n β€ 10^5) β the size of the permutation.
The second line of the test case contains n different integers p_1, p_2, β¦, p_n (1 β€ p_i β€ n) β the permutation written by Denis.
It is guaranteed that the sum of n over all test cases doesn't exceed 10^5.
Output
Print "Yes" if this permutation could be obtained as a result of the generator. Otherwise, print "No".
All letters can be displayed in any case.
Example
Input
5
5
2 3 4 5 1
1
1
3
1 3 2
4
4 2 3 1
5
1 5 2 4 3
Output
Yes
Yes
No
Yes
No
Note
Let's simulate the operation of the generator in the first test.
At the 1 step, r = [1, 2, 3, 4, 5], count = [1, 1, 1, 1, 1]. The maximum value is reached in any free position, so the generator can choose a random position from 1 to 5. In our example, it chose 5.
At the 2 step, r = [1, 2, 3, 4, Γ], count = [1, 1, 1, 1, 0]. The maximum value is reached in positions from 1 to 4, so the generator can choose a random position among them. In our example, it chose 1.
At the 3 step, r = [2, 2, 3, 4, Γ], count = [0, 2, 1, 1, 0]. The maximum value is 2 and is reached only at the 2 position, so the generator will choose this position.
At the 4 step, r = [3, 3, 3, 4, Γ], count = [0, 0, 3, 1, 0]. The maximum value is 3 and is reached only at the 3 position, so the generator will choose this position.
At the 5 step, r = [4, 4, 4, 4, Γ], count = [0, 0, 0, 4, 0]. The maximum value is 4 and is reached only at the 4 position, so the generator will choose this position.
In total, we got a permutation of 2, 3, 4, 5, 1, that is, a generator could generate it.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
int nums[n];
bool good = 1;
for (int i = 0; i < n; i++) {
cin >> nums[i];
if (i && nums[i] > nums[i - 1] + 1) {
good = 0;
}
}
cout << (good ? "Yes" : "No") << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
for (int i = 0; i < t; i++) {
solve();
}
return 0;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
In Finite Encyclopedia of Integer Sequences (FEIS), all integer sequences of lengths between 1 and N (inclusive) consisting of integers between 1 and K (inclusive) are listed.
Let the total number of sequences listed in FEIS be X. Among those sequences, find the (X/2)-th (rounded up to the nearest integer) lexicographically smallest one.
Constraints
* 1 \leq N,K \leq 3 Γ 10^5
* N and K are integers.
Input
Input is given from Standard Input in the following format:
K N
Output
Print the (X/2)-th (rounded up to the nearest integer) lexicographically smallest sequence listed in FEIS, with spaces in between, where X is the total number of sequences listed in FEIS.
Examples
Input
3 2
Output
2 1
Input
2 4
Output
1 2 2 2
Input
5 14
Output
3 3 3 3 3 3 3 3 3 3 3 3 2 2
### Response
```cpp
#include"bits/stdc++.h"
using namespace std;
using ll = int64_t;
int main() {
ll K, N;
cin >> K >> N;
vector<ll> ans;
if (K % 2 == 0) {
ans.push_back(K / 2);
for (ll i = 0; i < N - 1; i++) {
ans.push_back(K);
}
} else {
for (ll i = 0; i < N; i++) {
ans.push_back((K + 1) / 2);
}
for (ll i = 0; i < N / 2; i++) {
if (ans.back() == 1) {
ans.erase(ans.end() - 1);
} else {
ans.back()--;
while (ans.size() != N) {
ans.push_back(K);
}
}
}
}
for (ll i = 0; i < ans.size(); i++) {
cout << ans[i] << " \n"[i == ans.size() - 1];
}
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
Given are N points (x_i, y_i) in a two-dimensional plane.
Find the minimum radius of a circle such that all the points are inside or on it.
Constraints
* 2 \leq N \leq 50
* 0 \leq x_i \leq 1000
* 0 \leq y_i \leq 1000
* The given N points are all different.
* The values in input are all integers.
Input
Input is given from Standard Input in the following format:
N
x_1 y_1
:
x_N y_N
Output
Print the minimum radius of a circle such that all the N points are inside or on it.
Your output will be considered correct if the absolute or relative error from our answer is at most 10^{-6}.
Examples
Input
2
0 0
1 0
Output
0.500000000000000000
Input
3
0 0
0 1
1 0
Output
0.707106781186497524
Input
10
10 9
5 9
2 0
0 0
2 7
3 3
2 5
10 0
3 7
1 9
Output
6.726812023536805158
### Response
```cpp
#include <cstdio>
#include <cmath>
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<cctype>
#include<math.h>
#include<string>
#include<string.h>
#include<stack>
#include<queue>
#include<vector>
#include<utility>
#include<set>
#include<map>
#include<stdlib.h>
#include<iomanip>
#include<complex>
using namespace std;
#define all(in) in.begin(),in.end()
#define shosu(x) fixed<<setprecision(x)
int n;
double x[1005], y[1005], X, Y, d, e;
double dist(double a, double b) {
return a*a + b*b;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%lf%lf", &x[i], &y[i]);
X += x[i]; Y += y[i];
}
X /= n; Y /= n;
double P = 0.1;
for (int i = 0; i < 30000; i++) {
int f = 0;
d = dist(X - x[0], Y - y[0]);
for (int j = 1; j < n; j++) {
e = dist(X - x[j], Y - y[j]);
if (d < e) { d = e; f = j; }
}
X += (x[f] - X)*P;
Y += (y[f] - Y)*P;
P *= 0.999;
}
cout << shosu(10) << sqrt(d) << endl;
//printf("%.3lf %.3lf\n%.3lf", X, Y, sqrt(d));
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
Compute A + B.
Constraints
* -1000 β€ A, B β€ 1000
Input
The input will consist of a series of pairs of integers A and B separated by a space, one pair of integers per line. The input will be terminated by EOF.
Output
For each pair of input integers A and B, you must output the sum of A and B in one line.
Example
Input
1 2
10 5
100 20
Output
3
15
120
### Response
```cpp
#include <iostream>
#include <cstdio>
using namespace std;
int main(){
int i,j;
while(scanf("%d %d",&i,&j) != EOF){
cout << i+j << endl;
}
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
We guessed a permutation p consisting of n integers. The permutation of length n is the array of length n where each element from 1 to n appears exactly once. This permutation is a secret for you.
For each position r from 2 to n we chose some other index l (l < r) and gave you the segment p_l, p_{l + 1}, ..., p_r in sorted order (i.e. we rearranged the elements of this segment in a way that the elements of this segment are sorted). Thus, you are given exactly n-1 segments of the initial permutation but elements inside each segment are sorted. The segments are given to you in random order.
For example, if the secret permutation is p=[3, 1, 4, 6, 2, 5] then the possible given set of segments can be:
* [2, 5, 6]
* [4, 6]
* [1, 3, 4]
* [1, 3]
* [1, 2, 4, 6]
Your task is to find any suitable permutation (i.e. any permutation corresponding to the given input data). It is guaranteed that the input data corresponds to some permutation (i.e. such permutation exists).
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 100) β the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (2 β€ n β€ 200) β the length of the permutation.
The next n-1 lines describe given segments.
The i-th line contains the description of the i-th segment. The line starts with the integer k_i (2 β€ k_i β€ n) β the length of the i-th segment. Then k_i integers follow. All integers in a line are distinct, sorted in ascending order, between 1 and n, inclusive.
It is guaranteed that the required p exists for each test case.
It is also guaranteed that the sum of n over all test cases does not exceed 200 (β n β€ 200).
Output
For each test case, print the answer: n integers p_1, p_2, ..., p_n (1 β€ p_i β€ n, all p_i should be distinct) β any suitable permutation (i.e. any permutation corresponding to the test case input).
Example
Input
5
6
3 2 5 6
2 4 6
3 1 3 4
2 1 3
4 1 2 4 6
5
2 2 3
2 1 2
2 1 4
2 4 5
7
3 1 2 6
4 1 3 5 6
2 1 2
3 4 5 7
6 1 2 3 4 5 6
3 1 3 6
2
2 1 2
5
2 2 5
3 2 3 5
4 2 3 4 5
5 1 2 3 4 5
Output
3 1 4 6 2 5
3 2 1 4 5
2 1 6 3 5 4 7
1 2
2 5 3 4 1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<set<int>> segs;
for (int i = 0; i < n - 1; i++) {
set<int> cur;
int k;
cin >> k;
for (int j = 0; j < k; j++) {
int x;
cin >> x;
cur.insert(x);
}
segs.push_back(cur);
}
for (int fst = 1; fst <= n; fst++) {
vector<int> ans;
bool ok = true;
vector<set<int>> cur = segs;
for (auto &it : cur) {
if (it.count(fst)) it.erase(fst);
}
ans.push_back(fst);
for (int i = 1; i < n; i++) {
int cnt1 = 0;
int nxt = -1;
for (auto &it : cur)
if (it.size() == 1) {
++cnt1;
nxt = *it.begin();
}
if (cnt1 != 1) {
ok = false;
break;
}
for (auto &it : cur)
if (it.count(nxt)) it.erase(nxt);
ans.push_back(nxt);
}
if (ok) {
set<set<int>> all(segs.begin(), segs.end());
for (int i = 1; i < n; ++i) {
set<int> seg;
seg.insert(ans[i]);
bool found = false;
for (int j = i - 1; j >= 0; --j) {
seg.insert(ans[j]);
if (all.count(seg)) {
found = true;
all.erase(seg);
break;
}
}
if (!found) ok = false;
}
}
if (ok) {
for (auto it : ans) cout << it << " ";
cout << endl;
break;
}
}
}
return 0;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
Given is an integer sequence A_1, ..., A_N of length N.
We will choose exactly \left\lfloor \frac{N}{2} \right\rfloor elements from this sequence so that no two adjacent elements are chosen.
Find the maximum possible sum of the chosen elements.
Here \lfloor x \rfloor denotes the greatest integer not greater than x.
Constraints
* 2 \leq N \leq 2\times 10^5
* |A_i|\leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_1 ... A_N
Output
Print the maximum possible sum of the chosen elements.
Examples
Input
6
1 2 3 4 5 6
Output
12
Input
5
-1000 -100 -10 0 10
Output
0
Input
10
1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000
Output
5000000000
Input
27
18 -28 18 28 -45 90 -45 23 -53 60 28 -74 -71 35 -26 -62 49 -77 57 24 -70 -93 69 -99 59 57 -49
Output
295
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=2e5+50;
int t,n,m;
int arr[maxn];
ll dp[maxn];
int main()
{
ios::sync_with_stdio(false);
cin>>n;
for(int i=1;i<=n;i++)
{
cin>>arr[i];
}
/* if(n%2==0)
{
ll fin0=0;
ll fin1=0;
for(int i=1;i<=n;i++)
{
if(i&1) fin1+=arr[i];
else fin0+=arr[i];
}
cout<<max(fin0,fin1)<<endl;
return 0;
}*/
ll sum[maxn];
sum[1]=arr[1];
for(int i=3;i<=n;i+=2)
{
sum[i]=sum[i-2]+arr[i];
}
for(int i=2;i<=n;i++)
{
if(i%2==1)
{
dp[i]=max(dp[i-1],dp[i-2]+arr[i]);
}
else
{
dp[i]=max(sum[i-1],dp[i-2]+arr[i]);
}
}
cout<<dp[n]<<endl;
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
Vanya wants to pass n exams and get the academic scholarship. He will get the scholarship if the average grade mark for all the exams is at least avg. The exam grade cannot exceed r. Vanya has passed the exams and got grade ai for the i-th exam. To increase the grade for the i-th exam by 1 point, Vanya must write bi essays. He can raise the exam grade multiple times.
What is the minimum number of essays that Vanya needs to write to get scholarship?
Input
The first line contains three integers n, r, avg (1 β€ n β€ 105, 1 β€ r β€ 109, 1 β€ avg β€ min(r, 106)) β the number of exams, the maximum grade and the required grade point average, respectively.
Each of the following n lines contains space-separated integers ai and bi (1 β€ ai β€ r, 1 β€ bi β€ 106).
Output
In the first line print the minimum number of essays.
Examples
Input
5 5 4
5 2
4 7
3 1
3 2
2 5
Output
4
Input
2 5 4
5 2
5 2
Output
0
Note
In the first sample Vanya can write 2 essays for the 3rd exam to raise his grade by 2 points and 2 essays for the 4th exam to raise his grade by 1 point.
In the second sample, Vanya doesn't need to write any essays as his general point average already is above average.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, r, avg;
cin >> n >> r >> avg;
vector<pair<long long int, long long int>> v;
long long int sum = 0;
for (long long int i = 0; i < n; i++) {
long long int a, b;
cin >> a >> b;
sum += a;
v.push_back(make_pair(b, a));
}
if (sum / n >= avg) {
cout << 0 << endl;
return 0;
}
long long int count_ = 0;
sort(v.begin(), v.end());
sum = n * avg - sum;
for (long long int i = 0; i < n; i++) {
if (sum <= 0) break;
if (sum >= r - v[i].second) {
count_ += (r - v[i].second) * (v[i].first);
sum = sum - (r - v[i].second);
} else {
count_ += sum * v[i].first;
sum = 0;
}
}
cout << count_ << endl;
return 0;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
You are given integers N and M.
Consider a sequence a of length N consisting of positive integers such that a_1 + a_2 + ... + a_N = M. Find the maximum possible value of the greatest common divisor of a_1, a_2, ..., a_N.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^5
* N \leq M \leq 10^9
Input
Input is given from Standard Input in the following format:
N M
Output
Print the maximum possible value of the greatest common divisor of a sequence a_1, a_2, ..., a_N that satisfies the condition.
Examples
Input
3 14
Output
2
Input
10 123
Output
3
Input
100000 1000000000
Output
10000
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
long long n,m,ans=0;
int main(){
cin>>n>>m;
for(long long i=1;i*i<=m;++i) {
if(m%i==0) {
if(m/i>=n) {
ans=max(ans,i);
}
if(i>=n) {
ans=max(ans,m/i);
}
}
}
cout<<ans<<endl;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
To get money for a new aeonic blaster, ranger Qwerty decided to engage in trade for a while. He wants to buy some number of items (or probably not to buy anything at all) on one of the planets, and then sell the bought items on another planet. Note that this operation is not repeated, that is, the buying and the selling are made only once. To carry out his plan, Qwerty is going to take a bank loan that covers all expenses and to return the loaned money at the end of the operation (the money is returned without the interest). At the same time, Querty wants to get as much profit as possible.
The system has n planets in total. On each of them Qwerty can buy or sell items of m types (such as food, medicine, weapons, alcohol, and so on). For each planet i and each type of items j Qwerty knows the following:
* aij β the cost of buying an item;
* bij β the cost of selling an item;
* cij β the number of remaining items.
It is not allowed to buy more than cij items of type j on planet i, but it is allowed to sell any number of items of any kind.
Knowing that the hold of Qwerty's ship has room for no more than k items, determine the maximum profit which Qwerty can get.
Input
The first line contains three space-separated integers n, m and k (2 β€ n β€ 10, 1 β€ m, k β€ 100) β the number of planets, the number of question types and the capacity of Qwerty's ship hold, correspondingly.
Then follow n blocks describing each planet.
The first line of the i-th block has the planet's name as a string with length from 1 to 10 Latin letters. The first letter of the name is uppercase, the rest are lowercase. Then in the i-th block follow m lines, the j-th of them contains three integers aij, bij and cij (1 β€ bij < aij β€ 1000, 0 β€ cij β€ 100) β the numbers that describe money operations with the j-th item on the i-th planet. The numbers in the lines are separated by spaces.
It is guaranteed that the names of all planets are different.
Output
Print a single number β the maximum profit Qwerty can get.
Examples
Input
3 3 10
Venus
6 5 3
7 6 5
8 6 10
Earth
10 9 0
8 6 4
10 9 3
Mars
4 3 0
8 4 12
7 2 5
Output
16
Note
In the first test case you should fly to planet Venus, take a loan on 74 units of money and buy three items of the first type and 7 items of the third type (3Β·6 + 7Β·8 = 74). Then the ranger should fly to planet Earth and sell there all the items he has bought. He gets 3Β·9 + 7Β·9 = 90 units of money for the items, he should give 74 of them for the loan. The resulting profit equals 16 units of money. We cannot get more profit in this case.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 110;
char st[Maxn];
int a[Maxn][Maxn], b[Maxn][Maxn], c[Maxn][Maxn];
int v[Maxn], num[Maxn];
int n, m, lim;
int main() {
scanf("%d%d%d", &n, &m, &lim);
for (int i = 0; i < n; ++i) {
scanf("%s", st);
for (int j = 0; j < m; ++j) scanf("%d%d%d", &a[i][j], &b[i][j], &c[i][j]);
}
int res = 0;
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j)
if (i != j) {
for (int k = 0; k < m; ++k) {
v[k] = b[j][k] - a[i][k];
num[k] = c[i][k];
}
for (int ii = 0; ii < m; ++ii)
for (int jj = ii + 1; jj < m; ++jj)
if (v[ii] < v[jj]) {
swap(v[ii], v[jj]);
swap(num[ii], num[jj]);
}
int z = 0;
int rest = lim;
for (int ii = 0; ii < m && v[ii] > 0 && rest > 0; ++ii) {
int use = min(rest, num[ii]);
z += v[ii] * use;
rest -= use;
}
res = max(res, z);
}
printf("%d\n", res);
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
Little C loves number Β«3Β» very much. He loves all things about it.
Now he has a positive integer n. He wants to split n into 3 positive integers a,b,c, such that a+b+c=n and none of the 3 integers is a multiple of 3. Help him to find a solution.
Input
A single line containing one integer n (3 β€ n β€ 10^9) β the integer Little C has.
Output
Print 3 positive integers a,b,c in a single line, such that a+b+c=n and none of them is a multiple of 3.
It can be proved that there is at least one solution. If there are multiple solutions, print any of them.
Examples
Input
3
Output
1 1 1
Input
233
Output
77 77 79
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
const long long inf = 1e17 + 7;
signed main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(0);
long long n;
cin >> n;
if (n % 3 == 2) {
cout << n - 3 << " " << 1 << " " << 2 << endl;
} else {
cout << n - 2 << " " << 1 << " " << 1 << endl;
}
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
We have a canvas divided into a grid with H rows and W columns. The square at the i-th row from the top and the j-th column from the left is represented as (i, j).
Initially, all the squares are white. square1001 wants to draw a picture with black paint. His specific objective is to make Square (i, j) black when s_{i, j}= `#`, and to make Square (i, j) white when s_{i, j}= `.`.
However, since he is not a good painter, he can only choose two squares that are horizontally or vertically adjacent and paint those squares black, for some number of times (possibly zero). He may choose squares that are already painted black, in which case the color of those squares remain black.
Determine if square1001 can achieve his objective.
Constraints
* H is an integer between 1 and 50 (inclusive).
* W is an integer between 1 and 50 (inclusive).
* For every (i, j) (1 \leq i \leq H, 1 \leq j \leq W), s_{i, j} is `#` or `.`.
Input
Input is given from Standard Input in the following format:
H W
s_{1, 1} s_{1, 2} s_{1, 3} ... s_{1, W}
s_{2, 1} s_{2, 2} s_{2, 3} ... s_{2, W}
: :
s_{H, 1} s_{H, 2} s_{H, 3} ... s_{H, W}
Output
If square1001 can achieve his objective, print `Yes`; if he cannot, print `No`.
Examples
Input
3 3
.#.
###
.#.
Output
Yes
Input
3 3
.#.
.#.
Output
Yes
Input
5 5
.#.#
.#.#.
.#.#
.#.#.
.#.#
Output
No
Input
11 11
...#####...
.##.....##.
..##.##..#
..##.##..#
.........#
...###...#
.#########.
.#.#.#.#.#.
.#.#.#.##
..##.#.##..
.##..#..##.
Output
Yes
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
int H ,W;
cin >> H >> W;
char c[55][55] ={'.'};
for(int i = 1; i <= H; i++){
for(int j = 1; j <= W; j++){
cin >> c[i][j];
}
}
for(int i = 1; i <=H; i++){
for(int j = 1; j<= W; j++){
if(c[i][j] == '#'){
if(c[i][j-1] != '#' && c[i][j+1] != '#' && c[i+1][j] != '#' &&c[i-1][j] != '#'){
cout << "No" << endl;
return 0;
}
}
}
}
cout << "Yes" << endl;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
A positive integer is called a 2-3-integer, if it is equal to 2xΒ·3y for some non-negative integers x and y. In other words, these integers are such integers that only have 2 and 3 among their prime divisors. For example, integers 1, 6, 9, 16 and 108 β are 2-3 integers, while 5, 10, 21 and 120 are not.
Print the number of 2-3-integers on the given segment [l, r], i. e. the number of sich 2-3-integers t that l β€ t β€ r.
Input
The only line contains two integers l and r (1 β€ l β€ r β€ 2Β·109).
Output
Print a single integer the number of 2-3-integers on the segment [l, r].
Examples
Input
1 10
Output
7
Input
100 200
Output
5
Input
1 2000000000
Output
326
Note
In the first example the 2-3-integers are 1, 2, 3, 4, 6, 8 and 9.
In the second example the 2-3-integers are 108, 128, 144, 162 and 192.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<long long int> a;
long long int nn = 1e9;
int main() {
long long int l, r;
scanf("%lld %lld", &l, &r);
for (long long int i = 0; i <= 30; ++i) {
for (long long int j = 0; j <= 20; ++j) {
long long int x = pow(2, i);
long long int y = pow(3, j);
if ((x > nn && y > nn) || x * y > 2 * nn) {
continue;
}
a.push_back(x * y);
}
}
sort(a.begin(), a.end());
int ans = 0;
for (int i = 0; i < (int)a.size(); ++i) {
if (a[i] > r) break;
if (a[i] >= l && a[i] <= r) ans++;
}
printf("%d\n", ans);
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
For a given polygon g, computes the area of the polygon.
g is represented by a sequence of points p1, p2,..., pn where line segments connecting pi and pi+1 (1 β€ i β€ n-1) are sides of g. The line segment connecting pn and p1 is also a side of the polygon.
Note that the polygon is not necessarily convex.
Constraints
* 3 β€ n β€ 100
* -10000 β€ xi, yi β€ 10000
* No point will occur more than once.
* Two sides can intersect only at a common endpoint.
Input
The input consists of coordinates of the points p1,..., pn in the following format:
n
x1 y1
x2 y2
:
xn yn
The first integer n is the number of points. The coordinate of a point pi is given by two integers xi and yi. The coordinates of points are given in the order of counter-clockwise visit of them.
Output
Print the area of the polygon in a line. The area should be printed with one digit to the right of the decimal point.
Examples
Input
3
0 0
2 2
-1 1
Output
2.0
Input
4
0 0
1 1
1 2
0 2
Output
1.5
### Response
```cpp
#include <iostream>
#include <complex>
#include <sstream>
#include <string>
#include <algorithm>
#include <deque>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <vector>
#include <set>
#include <limits>
#include <cstdio>
#include <cctype>
#include <cmath>
#include <cstring>
#include <cstdlib>
#include <ctime>
using namespace std;
#define REP(i, j) for(int i = 0; i < (int)(j); ++i)
#define FOR(i, j, k) for(int i = (int)(j); i < (int)(k); ++i)
#define SORT(v) sort((v).begin(), (v).end())
#define REVERSE(v) reverse((v).begin(), (v).end())
#define X real()
#define Y imag()
#define curr(P, i) P[i]
#define next(P, i) P[(i+1)%P.size()]
const double EPS = 1e-8;
const double INF = 1e12;
typedef complex<double> P;
namespace std {
bool operator < (const P& a, const P& b) {
return real(a) != real(b) ? real(a) < real(b) : imag(a) < imag(b);
}
}
typedef vector<P> G;
double cross(const P& a, const P& b) {
return imag(conj(a)*b);
}
double area2(const G &P) {
double A = 0.0;
for (int i = 0; i < P.size(); ++i)
A += cross(curr(P, i), next(P, i));
return A / 2.0;
}
int main() {
int N; cin >>N;
G g(N);
REP(i, N){
int x, y; cin >>x >>y;
g[i] = P(x, y);
}
printf("%.1lf\n", area2(g));
return 0;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
Let's assume that set S consists of m distinct intervals [l1, r1], [l2, r2], ..., [lm, rm] (1 β€ li β€ ri β€ n; li, ri are integers).
Let's assume that f(S) is the maximum number of intervals that you can choose from the set S, such that every two of them do not intersect. We assume that two intervals, [l1, r1] and [l2, r2], intersect if there is an integer x, which meets two inequalities: l1 β€ x β€ r1 and l2 β€ x β€ r2.
Sereja wonders, how many sets S are there, such that f(S) = k? Count this number modulo 1000000007 (109 + 7).
Input
The first line contains integers n, k (1 β€ n β€ 500; 0 β€ k β€ 500).
Output
In a single line, print the answer to the problem modulo 1000000007 (109 + 7).
Examples
Input
3 1
Output
23
Input
3 2
Output
32
Input
2 0
Output
1
Input
2 2
Output
2
### Response
```cpp
#include <bits/stdc++.h>
long long int mod = 1000000007;
long long int f[510][510];
long long int pp[1000000];
long long int ans;
int n, k;
void prepare() {
long long int cnt;
int i, j;
pp[0] = 1;
for (i = 1; i < 1000000; i++) pp[i] = (pp[i - 1] * 2) % mod;
for (i = 0; i <= 500; i++) f[i][0] = 1;
for (n = 1; n <= 500; n++)
for (k = 1; k <= n; k++) {
for (j = k; j <= n; j++) {
cnt = (pp[j * (n - j + 1)] - pp[(j - 1) * (n - j + 1)] + mod) % mod;
cnt = (f[j - 1][k - 1] * cnt) % mod;
f[n][k] = (f[n][k] + cnt);
}
f[n][k] %= mod;
}
}
int main() {
int i, j;
prepare();
scanf("%d %d", &n, &k);
printf("%lld\n", f[n][k]);
return 0;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
There are n distinct points on a coordinate line, the coordinate of i-th point equals to x_i. Choose a subset of the given set of points such that the distance between each pair of points in a subset is an integral power of two. It is necessary to consider each pair of points, not only adjacent. Note that any subset containing one element satisfies the condition above. Among all these subsets, choose a subset with maximum possible size.
In other words, you have to choose the maximum possible number of points x_{i_1}, x_{i_2}, ..., x_{i_m} such that for each pair x_{i_j}, x_{i_k} it is true that |x_{i_j} - x_{i_k}| = 2^d where d is some non-negative integer number (not necessarily the same for each pair of points).
Input
The first line contains one integer n (1 β€ n β€ 2 β
10^5) β the number of points.
The second line contains n pairwise distinct integers x_1, x_2, ..., x_n (-10^9 β€ x_i β€ 10^9) β the coordinates of points.
Output
In the first line print m β the maximum possible number of points in a subset that satisfies the conditions described above.
In the second line print m integers β the coordinates of points in the subset you have chosen.
If there are multiple answers, print any of them.
Examples
Input
6
3 5 4 7 10 12
Output
3
7 3 5
Input
5
-1 2 5 8 11
Output
1
8
Note
In the first example the answer is [7, 3, 5]. Note, that |7-3|=4=2^2, |7-5|=2=2^1 and |3-5|=2=2^1. You can't find a subset having more points satisfying the required property.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
map<int, pair<int, int>> m;
int main() {
int n;
scanf("%d", &n);
int a[n];
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
}
sort(a, a + n);
int po[35];
po[0] = 1;
for (int i = 1; i <= 30; i++) {
po[i] = (1 << i);
}
vector<pair<int, int>> ans[n];
pair<int, int> mx = {0, 0};
for (int i = 0; i < n; i++) {
pair<int, int> cnt = {0, 0};
for (int j = 0; j <= 30; j++) {
int c = 0;
int f = (upper_bound(a, a + n, a[i] + po[j]) - a) -
(lower_bound(a, a + n, a[i] + po[j]) - a);
int l = (upper_bound(a, a + n, a[i] + 2 * po[j]) - a) -
(lower_bound(a, a + n, a[i] + 2 * po[j]) - a);
c = l + f;
c += ((upper_bound(a, a + n, a[i]) - a) -
(lower_bound(a, a + n, a[i]) - a));
if (cnt.first < c) cnt = {c, j};
}
ans[i].push_back({a[i], po[cnt.second]});
if (cnt.first > mx.first) mx = {cnt.first, i};
}
printf("%d\n", mx.first);
for (auto i : ans[mx.second]) {
int st = (lower_bound(a, a + n, i.first) - a);
int en = (upper_bound(a, a + n, i.first) - a);
for (int j = st; j < en; j++) printf("%d ", a[j]);
st = lower_bound(a, a + n, i.first + i.second) - a;
en = upper_bound(a, a + n, i.first + i.second) - a;
for (int j = st; j < en; j++) printf("%d ", a[j]);
st = lower_bound(a, a + n, i.first + 2 * i.second) - a;
en = upper_bound(a, a + n, i.first + 2 * i.second) - a;
for (int j = st; j < en; j++) printf("%d ", a[j]);
}
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
We call an array almost increasing if we can erase not more than one element from it so that the array becomes strictly increasing (that is, every element is striclty greater than every element before it).
You are given an array a consisting of n elements. You are allowed to replace any element with any integer number (and you may do so any number of times you need). What is the minimum number of replacements you have to perform in order to make the array almost increasing?
Input
The first line contains one integer n (2 β€ n β€ 200000) β the number of elements in a.
The second line contains n integers a1, a2, ..., an (1 β€ ai β€ 109) β the array a.
Output
Print the minimum number of replaces you have to perform so that a is almost increasing.
Examples
Input
5
5 4 3 2 1
Output
3
Input
5
1 2 8 9 5
Output
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, neg = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') neg = -1;
c = getchar();
}
while (isdigit(c)) x = x * 10 + c - '0', c = getchar();
return x * neg;
}
inline void print(int x) {
if (x < 0) {
putchar('-');
print(abs(x));
return;
}
if (x <= 9)
putchar(x + '0');
else {
print(x / 10);
putchar(x % 10 + '0');
}
}
inline int qpow(int x, int e, int _MOD) {
int ans = 1;
while (e) {
if (e & 1) ans = ans * x % _MOD;
x = x * x % _MOD;
e >>= 1;
}
return ans;
}
int n = read(), a[200005], f[200005], g[200005], ans = 0;
signed main() {
for (int i = 1; i <= n; i++) a[i] = read();
memset(f, 0x3f, sizeof(f));
memset(g, 0x3f, sizeof(g));
for (int i = 2; i <= n; i++) {
int ind = upper_bound(g + 1, g + 1 + n, a[i] - i + 1) - g;
g[ind] = a[i] - i + 1;
ans = max(ans, ind);
ind = upper_bound(f + 1, f + 1 + n, a[i - 1] - i + 1) - f;
f[ind] = a[i - 1] - i + 1;
g[ind] = min(g[ind], f[ind]);
ans = max(ans, ind);
}
cout << n - 1 - ans << endl;
return 0;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
One way to create a task is to learn from life. You can choose some experience in real life, formalize it and then you will get a new task.
Let's think about a scene in real life: there are lots of people waiting in front of the elevator, each person wants to go to a certain floor. We can formalize it in the following way. We have n people standing on the first floor, the i-th person wants to go to the fi-th floor. Unfortunately, there is only one elevator and its capacity equal to k (that is at most k people can use it simultaneously). Initially the elevator is located on the first floor. The elevator needs |a - b| seconds to move from the a-th floor to the b-th floor (we don't count the time the people need to get on and off the elevator).
What is the minimal number of seconds that is needed to transport all the people to the corresponding floors and then return the elevator to the first floor?
Input
The first line contains two integers n and k (1 β€ n, k β€ 2000) β the number of people and the maximal capacity of the elevator.
The next line contains n integers: f1, f2, ..., fn (2 β€ fi β€ 2000), where fi denotes the target floor of the i-th person.
Output
Output a single integer β the minimal time needed to achieve the goal.
Examples
Input
3 2
2 3 4
Output
8
Input
4 2
50 100 50 100
Output
296
Input
10 3
2 2 2 2 2 2 2 2 2 2
Output
8
Note
In first sample, an optimal solution is:
1. The elevator takes up person #1 and person #2.
2. It goes to the 2nd floor.
3. Both people go out of the elevator.
4. The elevator goes back to the 1st floor.
5. Then the elevator takes up person #3.
6. And it goes to the 2nd floor.
7. It picks up person #2.
8. Then it goes to the 3rd floor.
9. Person #2 goes out.
10. Then it goes to the 4th floor, where person #3 goes out.
11. The elevator goes back to the 1st floor.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
int a[3000];
scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
a[i]--;
}
sort(a, a + n);
int ans = 0;
int i;
for (i = n - 1; i >= 0; i -= k) {
ans += a[i] * 2;
}
printf("%d\n", ans);
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
A permutation is a sequence of integers p1, p2, ..., pn, consisting of n distinct positive integers, each of them doesn't exceed n. Let's denote the i-th element of permutation p as pi. We'll call number n the size of permutation p1, p2, ..., pn.
Nickolas adores permutations. He likes some permutations more than the others. He calls such permutations perfect. A perfect permutation is such permutation p that for any i (1 β€ i β€ n) (n is the permutation size) the following equations hold ppi = i and pi β i. Nickolas asks you to print any perfect permutation of size n for the given n.
Input
A single line contains a single integer n (1 β€ n β€ 100) β the permutation size.
Output
If a perfect permutation of size n doesn't exist, print a single integer -1. Otherwise print n distinct integers from 1 to n, p1, p2, ..., pn β permutation p, that is perfect. Separate printed numbers by whitespaces.
Examples
Input
1
Output
-1
Input
2
Output
2 1
Input
4
Output
2 1 4 3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long inf = 0x7f7f7f7f;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
;
long long n;
cin >> n;
if (n & 1) {
cout << "-1" << endl;
return 0;
}
for (long long i = 0; i < n; i += 2) {
cout << i + 2 << " " << i + 1 << " ";
}
cout << endl;
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
There are n points marked on the plane. The points are situated in such a way that they form a regular polygon (marked points are its vertices, and they are numbered in counter-clockwise order). You can draw n - 1 segments, each connecting any two marked points, in such a way that all points have to be connected with each other (directly or indirectly).
But there are some restrictions. Firstly, some pairs of points cannot be connected directly and have to be connected undirectly. Secondly, the segments you draw must not intersect in any point apart from the marked points (that is, if any two segments intersect and their intersection is not a marked point, then the picture you have drawn is invalid).
How many ways are there to connect all vertices with n - 1 segments? Two ways are considered different iff there exist some pair of points such that a segment is drawn between them in the first way of connection, but it is not drawn between these points in the second one. Since the answer might be large, output it modulo 109 + 7.
Input
The first line contains one number n (3 β€ n β€ 500) β the number of marked points.
Then n lines follow, each containing n elements. ai, j (j-th element of line i) is equal to 1 iff you can connect points i and j directly (otherwise ai, j = 0). It is guaranteed that for any pair of points ai, j = aj, i, and for any point ai, i = 0.
Output
Print the number of ways to connect points modulo 109 + 7.
Examples
Input
3
0 0 1
0 0 1
1 1 0
Output
1
Input
4
0 1 1 1
1 0 1 1
1 1 0 1
1 1 1 0
Output
12
Input
3
0 0 0
0 0 1
0 1 0
Output
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, a[550][550];
long long f[550][550], g[550][550];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) scanf("%d", &a[i][j]);
for (int i = 1; i <= n; i++) f[i][i] = 1;
for (int l = 1; l < n; l++)
for (int i = 1; i + l <= n; i++) {
int j = i + l;
for (int k = i; k <= j; k++) {
if (k < j && a[i][j])
f[i][j] = (f[i][j] + (f[i][k] + g[i][k]) % 1000000007 *
((f[k + 1][j] + g[k + 1][j]) % 1000000007) %
1000000007) %
1000000007;
if (k > i && k < j && a[j][k])
g[i][j] = (g[i][j] +
(f[i][k] + g[i][k]) % 1000000007 * f[k][j] % 1000000007) %
1000000007;
}
}
printf("%I64d\n", (f[1][n] + g[1][n]) % 1000000007);
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
qd ucyhf yi q fhycu dkcruh mxeiu huluhiu yi q tyvvuhudj fhycu dkcruh. oekh jqia yi je vydt jxu djx ucyhf.
Input
jxu ydfkj sediyiji ev q iydwbu ydjuwuh d (1 β€ d β€ 11184) β jxu edu-rqiut ydtun ev jxu ucyhf je vydt.
Output
ekjfkj q iydwbu dkcruh.
Examples
Input
1
Output
13
### Response
```cpp
#include <bits/stdc++.h>
int diri[] = {-1, 0, 1, 0, -1, 1, 1, -1};
int dirj[] = {0, 1, 0, -1, 1, 1, -1, -1};
int compare(double d1, double d2) {
if (fabs(d1 - d2) < 1e-9) return 0;
if (d1 < d2) return -1;
return 1;
}
using namespace std;
const int maxPrime = 1000001;
bool isPrime[maxPrime];
void sievePrime() {
memset(isPrime, 1, sizeof(isPrime));
int i, j;
isPrime[0] = isPrime[1] = 0;
for (i = 2; i * i <= maxPrime; i++) {
if (isPrime[i])
for (j = i * i; j < maxPrime; j += i) {
isPrime[j] = 0;
}
}
}
int main() {
int n;
cin >> n;
sievePrime();
vector<int> ans;
vector<int> prim;
for (int i = 0; i < (int)maxPrime; i++) {
if (isPrime[i]) {
prim.push_back(i);
}
}
for (int i = 0; i < (int)prim.size(); i++) {
stringstream ss;
string s;
int t;
ss << prim[i];
ss >> s;
reverse(s.begin(), s.end());
stringstream tt(s);
tt >> t;
if (t != prim[i] && isPrime[t]) {
ans.push_back(prim[i]);
}
}
n--;
cout << ans[n] << endl;
return 0;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
One day Vasya the Hipster decided to count how many socks he had. It turned out that he had a red socks and b blue socks.
According to the latest fashion, hipsters should wear the socks of different colors: a red one on the left foot, a blue one on the right foot.
Every day Vasya puts on new socks in the morning and throws them away before going to bed as he doesn't want to wash them.
Vasya wonders, what is the maximum number of days when he can dress fashionable and wear different socks, and after that, for how many days he can then wear the same socks until he either runs out of socks or cannot make a single pair from the socks he's got.
Can you help him?
Input
The single line of the input contains two positive integers a and b (1 β€ a, b β€ 100) β the number of red and blue socks that Vasya's got.
Output
Print two space-separated integers β the maximum number of days when Vasya can wear different socks and the number of days when he can wear the same socks until he either runs out of socks or cannot make a single pair from the socks he's got.
Keep in mind that at the end of the day Vasya throws away the socks that he's been wearing on that day.
Examples
Input
3 1
Output
1 1
Input
2 3
Output
2 0
Input
7 3
Output
3 2
Note
In the first sample Vasya can first put on one pair of different socks, after that he has two red socks left to wear on the second day.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, ans1 = 0, ans2 = 0, temp;
cin >> a >> b;
if (a >= b) {
ans1 = b;
temp = a - b;
ans2 = temp / 2;
} else if (a <= b) {
ans1 = a;
temp = b - a;
ans2 = temp / 2;
}
cout << ans1 << " " << ans2 << endl;
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
Vasya is choosing a laptop. The shop has n laptops to all tastes.
Vasya is interested in the following properties: processor speed, ram and hdd. Vasya is a programmer and not a gamer which is why he is not interested in all other properties.
If all three properties of a laptop are strictly less than those properties of some other laptop, then the first laptop is considered outdated by Vasya. Among all laptops Vasya does not consider outdated, he chooses the cheapest one.
There are very many laptops, which is why Vasya decided to write a program that chooses the suitable laptop. However, Vasya doesn't have his own laptop yet and he asks you to help him.
Input
The first line contains number n (1 β€ n β€ 100).
Then follow n lines. Each describes a laptop as speed ram hdd cost. Besides,
* speed, ram, hdd and cost are integers
* 1000 β€ speed β€ 4200 is the processor's speed in megahertz
* 256 β€ ram β€ 4096 the RAM volume in megabytes
* 1 β€ hdd β€ 500 is the HDD in gigabytes
* 100 β€ cost β€ 1000 is price in tugriks
All laptops have different prices.
Output
Print a single number β the number of a laptop Vasya will choose. The laptops are numbered with positive integers from 1 to n in the order in which they are given in the input data.
Examples
Input
5
2100 512 150 200
2000 2048 240 350
2300 1024 200 320
2500 2048 80 300
2000 512 180 150
Output
4
Note
In the third sample Vasya considers the first and fifth laptops outdated as all of their properties cannot match those of the third laptop. The fourth one is the cheapest among the laptops that are left. Thus, Vasya chooses the fourth laptop.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long n, k, m, i, j, a[1100], speed[1001], ram[1001], hdd[1001], cost[1001];
int main() {
cin >> n;
for (i = 1; i <= n; i++) cin >> speed[i] >> ram[i] >> hdd[i] >> cost[i];
for (i = 1; i <= n; i++)
if (a[i] == 0)
for (j = 1; j <= n; j++)
if (i != j && a[j] == 0) {
if (speed[i] > speed[j] && ram[i] > ram[j] && hdd[i] > hdd[j])
a[j] = 1;
if (speed[i] < speed[j] && ram[i] < ram[j] && hdd[i] < hdd[j]) {
a[i] = 1;
break;
}
}
k = 10000;
m = 1;
for (i = 1; i <= n; i++)
if (a[i] == 0 && k > cost[i]) {
k = cost[i];
m = i;
}
cout << endl << m;
return 0;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
Vasya has a tree consisting of n vertices with root in vertex 1. At first all vertices has 0 written on it.
Let d(i, j) be the distance between vertices i and j, i.e. number of edges in the shortest path from i to j. Also, let's denote k-subtree of vertex x β set of vertices y such that next two conditions are met:
* x is the ancestor of y (each vertex is the ancestor of itself);
* d(x, y) β€ k.
Vasya needs you to process m queries. The i-th query is a triple v_i, d_i and x_i. For each query Vasya adds value x_i to each vertex from d_i-subtree of v_i.
Report to Vasya all values, written on vertices of the tree after processing all queries.
Input
The first line contains single integer n (1 β€ n β€ 3 β
10^5) β number of vertices in the tree.
Each of next n - 1 lines contains two integers x and y (1 β€ x, y β€ n) β edge between vertices x and y. It is guarantied that given graph is a tree.
Next line contains single integer m (1 β€ m β€ 3 β
10^5) β number of queries.
Each of next m lines contains three integers v_i, d_i, x_i (1 β€ v_i β€ n, 0 β€ d_i β€ 10^9, 1 β€ x_i β€ 10^9) β description of the i-th query.
Output
Print n integers. The i-th integers is the value, written in the i-th vertex after processing all queries.
Examples
Input
5
1 2
1 3
2 4
2 5
3
1 1 1
2 0 10
4 10 100
Output
1 11 1 100 0
Input
5
2 3
2 1
5 4
3 4
5
2 0 4
3 10 1
1 2 3
2 3 10
1 1 7
Output
10 24 14 11 11
Note
In the first exapmle initial values in vertices are 0, 0, 0, 0, 0. After the first query values will be equal to 1, 1, 1, 0, 0. After the second query values will be equal to 1, 11, 1, 0, 0. After the third query values will be equal to 1, 11, 1, 100, 0.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void update(vector<long long int>& arr, int s, int e,
vector<long long int>& segment, int sind, int ind,
long long int val) {
if (s == e) {
arr[ind] += val;
segment[sind] += val;
} else {
int m = (s + e) / 2;
if (ind <= m) {
update(arr, s, m, segment, 2 * sind + 1, ind, val);
} else {
update(arr, m + 1, e, segment, 2 * sind + 2, ind, val);
}
segment[sind] = segment[2 * sind + 1] + segment[2 * sind + 2];
}
}
long long int query(vector<long long int>& arr, int s, int e,
vector<long long int>& segment, int sind, int l, int r) {
if (l > r) return 0LL;
if (s == l && e == r) return segment[sind];
int m = (s + e) / 2;
long long int left = query(arr, s, m, segment, 2 * sind + 1, l, min(m, r));
long long int right =
query(arr, m + 1, e, segment, 2 * sind + 2, max(m + 1, l), r);
return left + right;
}
void traverse(int u, vector<vector<int>>& adj, vector<int>& visit,
vector<vector<pair<int, int>>>& queries,
vector<long long int>& vals, int d, vector<long long int>& arr,
vector<long long int>& seg) {
visit[u] = 1;
int n = adj.size();
for (int i = 0; i < queries[u].size(); i++) {
update(arr, 0, n - 1, seg, 0, min(n - 1, d + queries[u][i].first),
queries[u][i].second);
}
vals[u] = query(arr, 0, n - 1, seg, 0, d, n - 1);
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (visit[v] == 0) {
traverse(v, adj, visit, queries, vals, d + 1, arr, seg);
}
}
for (int i = 0; i < queries[u].size(); i++) {
update(arr, 0, n - 1, seg, 0, min(n - 1, d + queries[u][i].first),
-1 * queries[u][i].second);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<long long int> arr(n, 0), segment(4 * n, 0);
vector<vector<int>> adj(n, vector<int>());
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
adj[a - 1].push_back(b - 1);
adj[b - 1].push_back(a - 1);
}
vector<vector<pair<int, int>>> queries(n, vector<pair<int, int>>());
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int v, d, x;
cin >> v >> d >> x;
queries[v - 1].push_back({d, x});
}
vector<int> visit(n, 0);
vector<long long int> values(n, 0);
traverse(0, adj, visit, queries, values, 0, arr, segment);
for (auto val : values) cout << val << " ";
cout << endl;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
Nastya received a gift on New Year β a magic wardrobe. It is magic because in the end of each month the number of dresses in it doubles (i.e. the number of dresses becomes twice as large as it is in the beginning of the month).
Unfortunately, right after the doubling the wardrobe eats one of the dresses (if any) with the 50% probability. It happens every month except the last one in the year.
Nastya owns x dresses now, so she became interested in the [expected number](https://en.wikipedia.org/wiki/Expected_value) of dresses she will have in one year. Nastya lives in Byteland, so the year lasts for k + 1 months.
Nastya is really busy, so she wants you to solve this problem. You are the programmer, after all. Also, you should find the answer modulo 109 + 7, because it is easy to see that it is always integer.
Input
The only line contains two integers x and k (0 β€ x, k β€ 1018), where x is the initial number of dresses and k + 1 is the number of months in a year in Byteland.
Output
In the only line print a single integer β the expected number of dresses Nastya will own one year later modulo 109 + 7.
Examples
Input
2 0
Output
4
Input
2 1
Output
7
Input
3 2
Output
21
Note
In the first example a year consists on only one month, so the wardrobe does not eat dresses at all.
In the second example after the first month there are 3 dresses with 50% probability and 4 dresses with 50% probability. Thus, in the end of the year there are 6 dresses with 50% probability and 8 dresses with 50% probability. This way the answer for this test is (6 + 8) / 2 = 7.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long power(long long x, long long y, int p) {
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;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long x, k, h, ans;
cin >> x >> k;
int p = 1000000007;
h = power(2, k, p);
ans = (((h % p * (2 * (x % p) - 1 % p) % p + p) % p) % p + 1) % p;
if (x == 0)
cout << 0 << endl;
else
cout << ans << endl;
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
Arthur and Alexander are number busters. Today they've got a competition.
Arthur took a group of four integers a, b, w, x (0 β€ b < w, 0 < x < w) and Alexander took integer Ρ. Arthur and Alexander use distinct approaches to number bustings. Alexander is just a regular guy. Each second, he subtracts one from his number. In other words, he performs the assignment: c = c - 1. Arthur is a sophisticated guy. Each second Arthur performs a complex operation, described as follows: if b β₯ x, perform the assignment b = b - x, if b < x, then perform two consecutive assignments a = a - 1; b = w - (x - b).
You've got numbers a, b, w, x, c. Determine when Alexander gets ahead of Arthur if both guys start performing the operations at the same time. Assume that Alexander got ahead of Arthur if c β€ a.
Input
The first line contains integers a, b, w, x, c (1 β€ a β€ 2Β·109, 1 β€ w β€ 1000, 0 β€ b < w, 0 < x < w, 1 β€ c β€ 2Β·109).
Output
Print a single integer β the minimum time in seconds Alexander needs to get ahead of Arthur. You can prove that the described situation always occurs within the problem's limits.
Examples
Input
4 2 3 1 6
Output
2
Input
4 2 3 1 7
Output
4
Input
1 2 3 2 6
Output
13
Input
1 1 2 1 1
Output
0
### Response
```cpp
#include <bits/stdc++.h>
int t[10001];
int C[10001];
int v[10001];
int a, b, x, w, c, times, st;
bool check(long long x) {
long long y = x / (times - st);
x = x % (times - st);
long long z = a - y * (C[times] - C[st]), zz = c - y * (times - st);
if (zz <= z) return true;
for (int i = 1; i <= x; ++i) {
if (C[st + i] != C[st + i - 1]) --z;
--zz;
if (zz <= z) return true;
}
return false;
}
int main() {
scanf("%d%d%d%d%d", &a, &b, &w, &x, &c);
int bb = b;
v[b] = 1;
t[1] = b;
for (times = 2;; ++times) {
if (bb >= x)
bb -= x, C[times] = C[times - 1];
else
bb = w - (x - bb), C[times] = C[times - 1] + 1;
t[times] = bb;
if (!v[bb])
v[bb] = times;
else {
st = v[bb];
break;
}
}
for (int i = 1; i < times; ++i) {
if (c <= a) {
printf("%d\n", i - 1);
return 0;
}
if (b >= x)
b -= x;
else
--a, b = w - (x - b);
--c;
}
if (c <= a) {
printf("%d\n", times - 1);
return 0;
}
long long lans = 0, rans = ~0ULL >> 2;
while (lans + 1 != rans) {
long long mid = (lans + rans) / 2;
if (check(mid))
rans = mid;
else
lans = mid;
}
std::cout << lans + times << std::endl;
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
On Planet MM-21, after their Olympic games this year, curling is getting popular. But the rules are somewhat different from ours. The game is played on an ice game board on which a square mesh is marked. They use only a single stone. The purpose of the game is to lead the stone from the start to the goal with the minimum number of moves.
Fig. D-1 shows an example of a game board. Some squares may be occupied with blocks. There are two special squares namely the start and the goal, which are not occupied with blocks. (These two squares are distinct.) Once the stone begins to move, it will proceed until it hits a block. In order to bring the stone to the goal, you may have to stop the stone by hitting it against a block, and throw again.
<image>
Fig. D-1: Example of board (S: start, G: goal)
The movement of the stone obeys the following rules:
* At the beginning, the stone stands still at the start square.
* The movements of the stone are restricted to x and y directions. Diagonal moves are prohibited.
* When the stone stands still, you can make it moving by throwing it. You may throw it to any direction unless it is blocked immediately(Fig. D-2(a)).
* Once thrown, the stone keeps moving to the same direction until one of the following occurs:
* The stone hits a block (Fig. D-2(b), (c)).
* The stone stops at the square next to the block it hit.
* The block disappears.
* The stone gets out of the board.
* The game ends in failure.
* The stone reaches the goal square.
* The stone stops there and the game ends in success.
* You cannot throw the stone more than 10 times in a game. If the stone does not reach the goal in 10 moves, the game ends in failure.
<image>
Fig. D-2: Stone movements
Under the rules, we would like to know whether the stone at the start can reach the goal and, if yes, the minimum number of moves required.
With the initial configuration shown in Fig. D-1, 4 moves are required to bring the stone from the start to the goal. The route is shown in Fig. D-3(a). Notice when the stone reaches the goal, the board configuration has changed as in Fig. D-3(b).
<image>
Fig. D-3: The solution for Fig. D-1 and the final board configuration
Input
The input is a sequence of datasets. The end of the input is indicated by a line containing two zeros separated by a space. The number of datasets never exceeds 100.
Each dataset is formatted as follows.
> the width(=w) and the height(=h) of the board
> First row of the board
> ...
> h-th row of the board
>
The width and the height of the board satisfy: 2 <= w <= 20, 1 <= h <= 20.
Each line consists of w decimal numbers delimited by a space. The number describes the status of the corresponding square.
> 0 | vacant square
> ---|---
> 1 | block
> 2 | start position
> 3 | goal position
The dataset for Fig. D-1 is as follows:
> 6 6
> 1 0 0 2 1 0
> 1 1 0 0 0 0
> 0 0 0 0 0 3
> 0 0 0 0 0 0
> 1 0 0 0 0 1
> 0 1 1 1 1 1
>
Output
For each dataset, print a line having a decimal integer indicating the minimum number of moves along a route from the start to the goal. If there are no such routes, print -1 instead. Each line should not have any character other than this number.
Example
Input
2 1
3 2
6 6
1 0 0 2 1 0
1 1 0 0 0 0
0 0 0 0 0 3
0 0 0 0 0 0
1 0 0 0 0 1
0 1 1 1 1 1
6 1
1 1 2 1 1 3
6 1
1 0 2 1 1 3
12 1
2 0 1 1 1 1 1 1 1 1 1 3
13 1
2 0 1 1 1 1 1 1 1 1 1 1 3
0 0
Output
1
4
-1
4
10
-1
### Response
```cpp
#include <iostream>
using namespace std;
int dx[]={-1,0,1,0};
int dy[]={0,-1,0,1};
#define INF (1<<24)
int f[30][30],W,H;
int dfs(int x, int y, int c, bool gf)
{
if(gf) return c;
if(c>=10) return INF;
int ret=INF;
for(int i=0; i<4; i++)
{
int tx=x, ty=y;
bool gf=false;
while(1)
{
tx+=dx[i], ty+=dy[i];
if(tx<0||ty<0||tx>=W||ty>=H) break;
if(f[tx][ty]==3) gf=1;
if(f[tx][ty]==1) break;
}
if(gf)
{
ret=min(ret, dfs(tx,ty,c+1,gf));
}
else
{
if(tx<0||ty<0||tx>=W||ty>=H) continue;
if(x==tx-dx[i]&&y==ty-dy[i]) continue;
f[tx][ty]=0;
tx-=dx[i], ty-=dy[i];
ret=min(ret, dfs(tx,ty,c+1,gf));
tx+=dx[i], ty+=dy[i];
f[tx][ty]=1;
}
}
return ret;
}
int main()
{
while(cin >> W >> H, (W||H))
{
int sx,sy;
for(int i=0; i<H; i++)
for(int j=0; j<W; j++)
{
cin >> f[j][i];
if(f[j][i]==2)
{
sx=j;
sy=i;
}
}
int ret=dfs(sx,sy,0,0);
cout << (ret==INF?-1:ret) << endl;
}
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
There are n seats in the train's car and there is exactly one passenger occupying every seat. The seats are numbered from 1 to n from left to right. The trip is long, so each passenger will become hungry at some moment of time and will go to take boiled water for his noodles. The person at seat i (1 β€ i β€ n) will decide to go for boiled water at minute t_i.
Tank with a boiled water is located to the left of the 1-st seat. In case too many passengers will go for boiled water simultaneously, they will form a queue, since there can be only one passenger using the tank at each particular moment of time. Each passenger uses the tank for exactly p minutes. We assume that the time it takes passengers to go from their seat to the tank is negligibly small.
Nobody likes to stand in a queue. So when the passenger occupying the i-th seat wants to go for a boiled water, he will first take a look on all seats from 1 to i - 1. In case at least one of those seats is empty, he assumes that those people are standing in a queue right now, so he would be better seating for the time being. However, at the very first moment he observes that all seats with numbers smaller than i are busy, he will go to the tank.
There is an unspoken rule, that in case at some moment several people can go to the tank, than only the leftmost of them (that is, seating on the seat with smallest number) will go to the tank, while all others will wait for the next moment.
Your goal is to find for each passenger, when he will receive the boiled water for his noodles.
Input
The first line contains integers n and p (1 β€ n β€ 100 000, 1 β€ p β€ 10^9) β the number of people and the amount of time one person uses the tank.
The second line contains n integers t_1, t_2, ..., t_n (0 β€ t_i β€ 10^9) β the moments when the corresponding passenger will go for the boiled water.
Output
Print n integers, where i-th of them is the time moment the passenger on i-th seat will receive his boiled water.
Example
Input
5 314
0 310 942 628 0
Output
314 628 1256 942 1570
Note
Consider the example.
At the 0-th minute there were two passengers willing to go for a water, passenger 1 and 5, so the first passenger has gone first, and returned at the 314-th minute. At this moment the passenger 2 was already willing to go for the water, so the passenger 2 has gone next, and so on. In the end, 5-th passenger was last to receive the boiled water.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long x = 0, f = 1;
char ch = getchar();
for (; ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') f = -1;
for (; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0';
return x * f;
}
void write(long long x) {
if (x < 0)
putchar('-'), write(-x);
else {
if (x >= 10) write(x / 10);
putchar(x % 10 + '0');
}
}
const long long N = 600010, mod = 1e9 + 7;
bool operator<(pair<long long, long long> a, pair<long long, long long> b) {
return a.first < b.first;
}
multiset<long long> q1;
multiset<long long>::iterator it;
priority_queue<long long, vector<long long>, greater<long long> > q2;
long long n, p, t[N], id[N], ans[N], q[N], he, ta;
bool cmp(long long a, long long b) {
if (t[a] == t[b]) return a < b;
return t[a] < t[b];
}
int main() {
n = read();
p = read();
for (long long i = (1); i <= (n); ++i) t[i] = read(), id[i] = i;
sort(id + 1, id + n + 1, cmp);
long long pos = 0, now = 0;
for (;;) {
if (he == ta) {
if (ta == n) break;
++pos;
now = t[id[pos]];
q[++ta] = id[pos];
q1.insert(id[pos]);
}
long long x = q[++he], cur = x;
ans[x] = now + p;
now += p;
it = q1.lower_bound(x);
q1.erase(it);
for (; (pos < n) && (t[id[pos + 1]] <= now);) {
it = q1.begin();
if (((it != q1.end()) && ((*it) < id[pos + 1])) || (cur < id[pos + 1])) {
++pos;
q2.push(id[pos]);
} else {
++pos;
q1.insert(id[pos]);
q[++ta] = id[pos];
}
}
for (; (!q2.empty()) && ((he == ta) || ((q2.top() < (*q1.begin()))));) {
x = q2.top();
q2.pop();
q[++ta] = x;
q1.insert(x);
}
}
for (long long i = (1); i <= (n); ++i) write(ans[i]), putchar(' ');
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
While Patrick was gone shopping, Spongebob decided to play a little trick on his friend. The naughty Sponge browsed through Patrick's personal stuff and found a sequence a1, a2, ..., am of length m, consisting of integers from 1 to n, not necessarily distinct. Then he picked some sequence f1, f2, ..., fn of length n and for each number ai got number bi = fai. To finish the prank he erased the initial sequence ai.
It's hard to express how sad Patrick was when he returned home from shopping! We will just say that Spongebob immediately got really sorry about what he has done and he is now trying to restore the original sequence. Help him do this or determine that this is impossible.
Input
The first line of the input contains two integers n and m (1 β€ n, m β€ 100 000) β the lengths of sequences fi and bi respectively.
The second line contains n integers, determining sequence f1, f2, ..., fn (1 β€ fi β€ n).
The last line contains m integers, determining sequence b1, b2, ..., bm (1 β€ bi β€ n).
Output
Print "Possible" if there is exactly one sequence ai, such that bi = fai for all i from 1 to m. Then print m integers a1, a2, ..., am.
If there are multiple suitable sequences ai, print "Ambiguity".
If Spongebob has made a mistake in his calculations and no suitable sequence ai exists, print "Impossible".
Examples
Input
3 3
3 2 1
1 2 3
Output
Possible
3 2 1
Input
3 3
1 1 1
1 1 1
Output
Ambiguity
Input
3 3
1 2 1
3 3 3
Output
Impossible
Note
In the first sample 3 is replaced by 1 and vice versa, while 2 never changes. The answer exists and is unique.
In the second sample all numbers are replaced by 1, so it is impossible to unambiguously restore the original sequence.
In the third sample fi β 3 for all i, so no sequence ai transforms into such bi and we can say for sure that Spongebob has made a mistake.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int b[100000], f[100000], a[100000], d[100000 + 1];
int main() {
int n, m;
while (cin >> n >> m) {
for (int i = 0; i < n; ++i) cin >> f[i];
for (int i = 0; i < m; ++i) cin >> b[i];
memset(d, 0, sizeof(d));
for (int i = 0; i < n; ++i) {
if (d[f[i]] != 0)
d[f[i]] = -1;
else
d[f[i]] = i + 1;
}
int ok = 1;
for (int i = 0; i < m; ++i) {
if (d[b[i]] < 0) {
ok = -1;
} else if (!d[b[i]]) {
ok = 0;
break;
}
a[i] = d[b[i]];
}
if (ok < 0) {
cout << "Ambiguity" << endl;
} else if (!ok) {
cout << "Impossible" << endl;
} else {
cout << "Possible" << endl;
cout << a[0];
for (int i = 1; i < m; ++i) {
cout << " " << a[i];
}
cout << endl;
}
}
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
All Berland residents are waiting for an unprecedented tour of wizard in his Blue Helicopter over the cities of Berland!
It is well-known that there are n cities in Berland, some pairs of which are connected by bidirectional roads. Each pair of cities is connected by no more than one road. It is not guaranteed that the road network is connected, i.e. it is possible that you can't reach some city from some other.
The tour will contain several episodes. In each of the episodes:
* the wizard will disembark at some city x from the Helicopter;
* he will give a performance and show a movie for free at the city x;
* he will drive to some neighboring city y using a road;
* he will give a performance and show a movie for free at the city y;
* he will drive to some neighboring to y city z;
* he will give a performance and show a movie for free at the city z;
* he will embark the Helicopter and fly away from the city z.
It is known that the wizard doesn't like to use roads, so he agrees to use each road at most once (regardless of direction). In other words, for road between a and b he only can drive once from a to b, or drive once from b to a, or do not use this road at all.
The wizards wants to plan as many episodes as possible without violation the above rules. Help the wizard!
Please note that the wizard can visit the same city multiple times, the restriction is on roads only.
Input
The first line contains two integers n, m (1 β€ n β€ 2Β·105, 0 β€ m β€ 2Β·105) β the number of cities and the number of roads in Berland, respectively.
The roads description follow, one in each line. Each description is a pair of two integers ai, bi (1 β€ ai, bi β€ n, ai β bi), where ai and bi are the ids of the cities connected by the i-th road. It is guaranteed that there are no two roads connecting the same pair of cities. Every road is bidirectional. The cities are numbered from 1 to n.
It is possible that the road network in Berland is not connected.
Output
In the first line print w β the maximum possible number of episodes. The next w lines should contain the episodes in format x, y, z β the three integers denoting the ids of the cities in the order of the wizard's visits.
Examples
Input
4 5
1 2
3 2
2 4
3 4
4 1
Output
2
1 4 2
4 3 2
Input
5 8
5 3
1 2
4 5
5 1
2 5
4 3
1 4
3 2
Output
4
1 4 5
2 3 4
1 5 3
5 2 1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int S = 2e5 + 10;
vector<int> tab[S], sons[S], extra[S];
vector<tuple<int, int, int>> ans;
int active[S], met[S], gb[S], x, y, n, m;
void dfs(int w, int par) {
met[w] = 1;
for (int v : tab[w]) {
if (!met[v]) {
gb[v] = gb[w] + 1;
dfs(v, w);
if (active[v]) sons[w].push_back(v);
} else {
if (gb[w] - gb[v] > 1) {
extra[w].push_back(v);
}
}
}
while (sons[w].size() >= 2) {
x = sons[w].back();
sons[w].pop_back();
y = sons[w].back();
sons[w].pop_back();
ans.push_back(make_tuple(x, w, y));
}
while (extra[w].size()) {
if (extra[w].size() >= 2) {
x = extra[w].back();
extra[w].pop_back();
y = extra[w].back();
extra[w].pop_back();
ans.push_back(make_tuple(x, w, y));
} else {
if (sons[w].size()) {
ans.push_back(make_tuple(sons[w][0], w, extra[w][0]));
sons[w].pop_back();
extra[w].pop_back();
} else {
ans.push_back(make_tuple(par, w, extra[w][0]));
extra[w].pop_back();
active[w] = 0;
}
}
}
if (sons[w].size() && par != -1) {
ans.push_back(make_tuple(par, w, sons[w][0]));
active[w] = 0;
sons[w].pop_back();
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int a = 1; a <= n; a++) active[a] = 1;
for (int a = 1; a <= m; a++) {
cin >> x >> y;
tab[x].push_back(y);
tab[y].push_back(x);
}
for (int a = 1; a <= n; a++) {
if (!met[a]) dfs(a, -1);
}
cout << ans.size() << endl;
for (auto v : ans) {
cout << get<0>(v) << " " << get<1>(v) << " " << get<2>(v) << endl;
}
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.