text
stringlengths 424
69.5k
|
|---|
### Prompt
Please formulate a cpp solution to the following problem:
Duff is the queen of her country, Andarz Gu. She's a competitive programming fan. That's why, when he saw her minister, Malek, free, she gave her a sequence consisting of n non-negative integers, a1, a2, ..., an and asked him to perform q queries for her on this sequence.
<image>
There are two types of queries:
1. given numbers l, r and k, Malek should perform <image> for each l ≤ i ≤ r (<image>, bitwise exclusive OR of numbers a and b).
2. given numbers l and r Malek should tell her the score of sequence al, al + 1, ... , ar.
Score of a sequence b1, ..., bk is the number of its different Kheshtaks. A non-negative integer w is a Kheshtak of this sequence if and only if there exists a subsequence of b, let's denote it as bi1, bi2, ... , bix (possibly empty) such that <image> (1 ≤ i1 < i2 < ... < ix ≤ k). If this subsequence is empty, then w = 0.
Unlike Duff, Malek is not a programmer. That's why he asked for your help. Please help him perform these queries.
Input
The first line of input contains two integers, n and q (1 ≤ n ≤ 2 × 105 and 1 ≤ q ≤ 4 × 104).
The second line of input contains n integers, a1, a2, ..., an separated by spaces (0 ≤ ai ≤ 109 for each 1 ≤ i ≤ n).
The next q lines contain the queries. Each line starts with an integer t (1 ≤ t ≤ 2), type of the corresponding query. If t = 1, then there are three more integers in that line, l, r and k. Otherwise there are two more integers, l and r. (1 ≤ l ≤ r ≤ n and 0 ≤ k ≤ 109)
Output
Print the answer of each query of the second type in one line.
Examples
Input
5 5
1 2 3 4 2
2 1 5
1 2 2 8
2 1 5
1 1 3 10
2 2 2
Output
8
16
1
Note
In the first query, we want all Kheshtaks of sequence 1, 2, 3, 4, 2 which are: 0, 1, 2, 3, 4, 5, 6, 7.
In the third query, we want all Khestaks of sequence 1, 10, 3, 4, 2 which are: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15.
In the fifth query, we want all Kheshtaks of sequence 0 which is 0.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int n, Q, a[maxn], opt, u, v, c;
struct Linear_Basis {
int bas[32], tag, x;
void init() {
memset(bas, 0, sizeof bas);
tag = 0;
x = 0;
}
int Count() {
int ret = 0;
for (int i = 0; i < 30; i++)
if (bas[i]) ret++;
return ret;
}
void ins(int o) {
for (int i = 29; ~i; i--) {
if ((o >> i) & 1) {
if (bas[i])
o ^= bas[i];
else {
bas[i] = o;
break;
}
}
}
}
Linear_Basis operator+(const Linear_Basis& rhs) const {
Linear_Basis ret;
ret.init();
for (int i = 0; i < 30; i++) {
ret.ins(bas[i]);
ret.ins(rhs.bas[i]);
}
ret.ins(x ^ rhs.x);
ret.x = rhs.x;
return ret;
}
} tr[maxn << 2], ans;
void build(int rt = 1, int st = 1, int ed = n) {
tr[rt].init();
if (st == ed) {
tr[rt].x = a[st];
return;
}
int mid = st + ed >> 1;
build(rt << 1, st, mid);
build(rt << 1 | 1, mid + 1, ed);
tr[rt] = tr[rt << 1] + tr[rt << 1 | 1];
}
void push_down(int rt) {
if (tr[rt].tag) {
tr[rt << 1].tag ^= tr[rt].tag;
tr[rt << 1].x ^= tr[rt].tag;
tr[rt << 1 | 1].tag ^= tr[rt].tag;
tr[rt << 1 | 1].x ^= tr[rt].tag;
tr[rt].tag = 0;
}
}
void update(int nl, int nr, int c, int rt = 1, int st = 1, int ed = n) {
if (nl <= st && nr >= ed) {
tr[rt].x ^= c;
tr[rt].tag ^= c;
return;
}
push_down(rt);
int mid = st + ed >> 1;
if (nl <= mid) update(nl, nr, c, rt << 1, st, mid);
if (nr >= mid + 1) update(nl, nr, c, rt << 1 | 1, mid + 1, ed);
tr[rt] = tr[rt << 1] + tr[rt << 1 | 1];
}
void query(int nl, int nr, int rt = 1, int st = 1, int ed = n) {
if (nl <= st && nr >= ed) {
ans = ans + tr[rt];
return;
}
push_down(rt);
int mid = st + ed >> 1;
if (nl <= mid) query(nl, nr, rt << 1, st, mid);
if (nr >= mid + 1) query(nl, nr, rt << 1 | 1, mid + 1, ed);
}
int main() {
scanf("%d %d", &n, &Q);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
build();
while (Q--) {
scanf("%d %d %d", &opt, &u, &v);
if (opt == 1) {
scanf("%d", &c);
update(u, v, c);
} else {
ans.init();
query(u, v);
printf("%d\n", 1 << ans.Count());
}
}
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
After many years of research, Ikta has acquired the ability to predict the future! The time and money he spent on this research was enormous, but it's finally time to be rewarded. To get the money back, Ikta decided to start investing in stocks.
Ikta does not currently own any shares, but owns x yen. He has invested in n stocks, and has succeeded in predicting the stock price for d days from today. As a result, it was surprisingly found that there was no intraday stock price fluctuation for d days from today. In other words, we know the stock price pi, j yen of the stock j (1 ≤ j ≤ n) on the i (1 ≤ i ≤ d) day when today is the first day. Ikta is free to buy and sell stocks each day. That is, the following operations (purchase / sale) can be performed at any time in any order and any number of times. However, the amount of money held and the number of units held of shares before and after each operation must be non-negative integers.
* Purchase: On day i, select one stock type j (1 ≤ j ≤ n) and pay pi, j yen in possession to obtain 1 unit of stock j.
* Sale: On day i, select one stock type j (1 ≤ j ≤ n) and pay 1 unit of stock j to get pi, j yen.
(While he was absorbed in his research, the securities trading system made great progress and there were no transaction fees.)
Ikta had studied information science at university, but had forgotten everything he had learned at university before he could devote himself to future prediction research. Instead of him, write a program that maximizes your money on the final day.
Input
The input is given in the following format.
n d x
p1,1 ... p1, n
...
pd, 1 ... pd, n
* n: Number of stock types
* d: days
* x: Money on the first day
* pi, j: Stock price of stock j on day i (today is the first day)
Constraints
Each variable being input is an integer that satisfies the following constraints.
* 1 ≤ n ≤ 10
* 1 ≤ d ≤ 10
* 1 ≤ x, pi, j ≤ 105
* It is guaranteed that the amount of money you have on the last day will be 105 or less.
Output
Output the last day's money in one line when you invest optimally.
Examples
Input
2 2 5
3 2
5 4
Output
9
Input
1 2 5
6
10000
Output
5
Input
2 3 5
4 5
6 3
8 5
Output
11
Input
3 3 10
10 9 6
8 7 3
7 5 1
Output
10
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, d, x;
cin >> n >> d >> x;
vector<vector<int> > p(d, vector<int>(n));
for (auto& i : p) for (auto& j : i) cin >> j;
vector<int> dp(100001);
dp[x] = 1;
for (int i = 0; i < d-1; i++) {
vector<int> s(100001);
for (int j = 0; j < n; j++) {
int sub = p[i+1][j] - p[i][j];
if (sub <= 0) continue;
for (int k = 0; k < 100001; k++) {
if (k - p[i][j] >= 0) s[k] = max(s[k], s[k - p[i][j]] + sub);
}
}
for (int j = 100000; j >= 0; j--)
if (j + s[j] < 100001) dp[j + s[j]] |= dp[j];
}
int ans = 0;
for (int i = 0; i < 100001; i++)
ans = max(ans, dp[i] * i);
cout << ans << endl;
return 0;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
Jabber ID on the national Berland service «Babber» has a form <username>@<hostname>[/resource], where
* <username> — is a sequence of Latin letters (lowercase or uppercase), digits or underscores characters «_», the length of <username> is between 1 and 16, inclusive.
* <hostname> — is a sequence of word separated by periods (characters «.»), where each word should contain only characters allowed for <username>, the length of each word is between 1 and 16, inclusive. The length of <hostname> is between 1 and 32, inclusive.
* <resource> — is a sequence of Latin letters (lowercase or uppercase), digits or underscores characters «_», the length of <resource> is between 1 and 16, inclusive.
The content of square brackets is optional — it can be present or can be absent.
There are the samples of correct Jabber IDs: [email protected], [email protected]/contest.
Your task is to write program which checks if given string is a correct Jabber ID.
Input
The input contains of a single line. The line has the length between 1 and 100 characters, inclusive. Each characters has ASCII-code between 33 and 127, inclusive.
Output
Print YES or NO.
Examples
Input
[email protected]
Output
YES
Input
[email protected]/contest.icpc/12
Output
NO
### Response
```cpp
#include <bits/stdc++.h>
int isAlpha(char x) { return x >= 'A' && x <= 'Z' || x >= 'a' && x <= 'z'; }
int isDigit(char x) { return x >= '0' && x <= '9'; }
int main(void) {
char a[100];
int flag = 0, i;
scanf("%[^@]", a);
for (i = 0; a[i]; i++)
if (isAlpha(a[i]) || isDigit(a[i]) || a[i] == '_')
;
else
flag = 1;
if (!a[i] && i >= 1 && i <= 16)
;
else {
flag = 1;
}
if (scanf("@%[^/\n\r]", a) == 0) {
flag = 1;
}
int c = 0;
for (i = 0; a[i]; i++)
if (isAlpha(a[i]) || isDigit(a[i]) || a[i] == '_') {
flag |= (++c > 16);
} else if (a[i] == '.') {
flag |= (c == 0);
c = 0;
} else
flag = 1;
if (c == 0) flag = 1;
if (i >= 1 && i <= 32)
;
else
flag = 1;
gets(a);
if (a[0] == '/') {
for (i = 1; a[i]; i++)
if (isAlpha(a[i]) || isDigit(a[i]) || a[i] == '_')
;
else
flag = 1;
if (i >= 2 && i <= 17)
;
else
flag = 1;
}
puts(flag ? "NO" : "YES");
return 0;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
Have you ever played Hanabi? If not, then you've got to try it out! This problem deals with a simplified version of the game.
Overall, the game has 25 types of cards (5 distinct colors and 5 distinct values). Borya is holding n cards. The game is somewhat complicated by the fact that everybody sees Borya's cards except for Borya himself. Borya knows which cards he has but he knows nothing about the order they lie in. Note that Borya can have multiple identical cards (and for each of the 25 types of cards he knows exactly how many cards of this type he has).
The aim of the other players is to achieve the state when Borya knows the color and number value of each of his cards. For that, other players can give him hints. The hints can be of two types: color hints and value hints.
A color hint goes like that: a player names some color and points at all the cards of this color.
Similarly goes the value hint. A player names some value and points at all the cards that contain the value.
Determine what minimum number of hints the other players should make for Borya to be certain about each card's color and value.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the number of Borya's cards. The next line contains the descriptions of n cards. The description of each card consists of exactly two characters. The first character shows the color (overall this position can contain five distinct letters — R, G, B, Y, W). The second character shows the card's value (a digit from 1 to 5). Borya doesn't know exact order of the cards they lie in.
Output
Print a single integer — the minimum number of hints that the other players should make.
Examples
Input
2
G3 G3
Output
0
Input
4
G4 R4 R3 B3
Output
2
Input
5
B1 Y1 W1 G1 R1
Output
4
Note
In the first sample Borya already knows for each card that it is a green three.
In the second sample we can show all fours and all red cards.
In the third sample you need to make hints about any four colors.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, tmp, res;
string a[101];
int gt(char z) {
if (z == 'R') return 0;
if (z == 'G') return 1;
if (z == 'B') return 2;
if (z == 'Y') return 3;
if (z == 'W') return 4;
return (4 + z - '0');
}
int solve(int x) {
int kt[10], count = 0, trues = 0, condi = 0;
for (int i = 0; i <= 9; i++) {
if (((x >> i) & 1) == 1) {
kt[i] = 1;
count++;
} else
kt[i] = 0;
}
for (int i = 1; i <= n - 1; i++) {
for (int j = i + 1; j <= n; j++)
if (a[i] != a[j]) {
trues = 1;
if ((a[i][0] != a[j][0]) and
((kt[gt(a[i][0])] == 1) or (kt[gt(a[j][0])] == 1)))
trues = 0;
if ((a[i][1] != a[j][1]) and
((kt[gt(a[i][1])] == 1) or (kt[gt(a[j][1])] == 1)))
trues = 0;
if (trues != 0) condi = 1;
if (condi == 1) break;
}
if (condi == 1) break;
}
if (condi != 0) return 0;
if (count < res) res = count;
return 0;
}
int main() {
scanf("%d\n", &n);
res = 11;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 0; i <= 1023; i++) tmp = solve(i);
cout << res;
return 0;
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
Mishka got a six-faced dice. It has integer numbers from 2 to 7 written on its faces (all numbers on faces are different, so this is an almost usual dice).
Mishka wants to get exactly x points by rolling his dice. The number of points is just a sum of numbers written at the topmost face of the dice for all the rolls Mishka makes.
Mishka doesn't really care about the number of rolls, so he just wants to know any number of rolls he can make to be able to get exactly x points for them. Mishka is very lucky, so if the probability to get x points with chosen number of rolls is non-zero, he will be able to roll the dice in such a way. Your task is to print this number. It is guaranteed that at least one answer exists.
Mishka is also very curious about different number of points to score so you have to answer t independent queries.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of queries.
Each of the next t lines contains one integer each. The i-th line contains one integer x_i (2 ≤ x_i ≤ 100) — the number of points Mishka wants to get.
Output
Print t lines. In the i-th line print the answer to the i-th query (i.e. any number of rolls Mishka can make to be able to get exactly x_i points for them). It is guaranteed that at least one answer exists.
Example
Input
4
2
13
37
100
Output
1
3
8
27
Note
In the first query Mishka can roll a dice once and get 2 points.
In the second query Mishka can roll a dice 3 times and get points 5, 5 and 3 (for example).
In the third query Mishka can roll a dice 8 times and get 5 points 7 times and 2 points with the remaining roll.
In the fourth query Mishka can roll a dice 27 times and get 2 points 11 times, 3 points 6 times and 6 points 10 times.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, t;
cin >> t;
for (int i = 0; i < t; i++) {
cin >> x;
cout << x / 2 << endl;
}
return 0;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
Recently Lynyrd and Skynyrd went to a shop where Lynyrd bought a permutation p of length n, and Skynyrd bought an array a of length m, consisting of integers from 1 to n.
Lynyrd and Skynyrd became bored, so they asked you q queries, each of which has the following form: "does the subsegment of a from the l-th to the r-th positions, inclusive, have a subsequence that is a cyclic shift of p?" Please answer the queries.
A permutation of length n is a sequence of n integers such that each integer from 1 to n appears exactly once in it.
A cyclic shift of a permutation (p_1, p_2, …, p_n) is a permutation (p_i, p_{i + 1}, …, p_{n}, p_1, p_2, …, p_{i - 1}) for some i from 1 to n. For example, a permutation (2, 1, 3) has three distinct cyclic shifts: (2, 1, 3), (1, 3, 2), (3, 2, 1).
A subsequence of a subsegment of array a from the l-th to the r-th positions, inclusive, is a sequence a_{i_1}, a_{i_2}, …, a_{i_k} for some i_1, i_2, …, i_k such that l ≤ i_1 < i_2 < … < i_k ≤ r.
Input
The first line contains three integers n, m, q (1 ≤ n, m, q ≤ 2 ⋅ 10^5) — the length of the permutation p, the length of the array a and the number of queries.
The next line contains n integers from 1 to n, where the i-th of them is the i-th element of the permutation. Each integer from 1 to n appears exactly once.
The next line contains m integers from 1 to n, the i-th of them is the i-th element of the array a.
The next q lines describe queries. The i-th of these lines contains two integers l_i and r_i (1 ≤ l_i ≤ r_i ≤ m), meaning that the i-th query is about the subsegment of the array from the l_i-th to the r_i-th positions, inclusive.
Output
Print a single string of length q, consisting of 0 and 1, the digit on the i-th positions should be 1, if the subsegment of array a from the l_i-th to the r_i-th positions, inclusive, contains a subsequence that is a cyclic shift of p, and 0 otherwise.
Examples
Input
3 6 3
2 1 3
1 2 3 1 2 3
1 5
2 6
3 5
Output
110
Input
2 4 3
2 1
1 1 2 2
1 2
2 3
3 4
Output
010
Note
In the first example the segment from the 1-st to the 5-th positions is 1, 2, 3, 1, 2. There is a subsequence 1, 3, 2 that is a cyclic shift of the permutation. The subsegment from the 2-nd to the 6-th positions also contains a subsequence 2, 1, 3 that is equal to the permutation. The subsegment from the 3-rd to the 5-th positions is 3, 1, 2, there is only one subsequence of length 3 (3, 1, 2), but it is not a cyclic shift of the permutation.
In the second example the possible cyclic shifts are 1, 2 and 2, 1. The subsegment from the 1-st to the 2-nd positions is 1, 1, its subsequences are not cyclic shifts of the permutation. The subsegment from the 2-nd to the 3-rd positions is 1, 2, it coincides with the permutation. The subsegment from the 3 to the 4 positions is 2, 2, its subsequences are not cyclic shifts of the permutation.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
int n, m, q;
int gde[maxn];
int poz[maxn];
int last[maxn];
int niz[maxn];
int lift[maxn][20];
template <class T, int SZ>
struct RMQ {
T sp[SZ][32 - __builtin_clz(SZ)];
void napravi(int N, int a[]) {
for (int i = 1; i <= N; i++) sp[i][0] = a[i];
for (int j = 1; j < 32 - __builtin_clz(SZ); j++) {
for (int i = 1; i <= SZ - (1 << (j - 1)); i++)
sp[i][j] = max(sp[i][j - 1], sp[i + (1 << (j - 1))][j - 1]);
}
}
T query(int l, int r) {
int x = 31 - __builtin_clz(r - l + 1);
return max(sp[l][x], sp[r - (1 << x) + 1][x]);
}
};
RMQ<long long, maxn> rq;
int nadji(int x) {
int kol = n - 1;
for (int i = 19; i >= 0; i--) {
int pw = (1 << i);
if (kol >= pw) {
kol -= pw;
x = lift[x][i];
}
}
return x;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cin >> n >> m >> q;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
poz[x] = i;
}
for (int i = 1; i <= m; i++) {
int x;
cin >> x;
gde[i] = poz[x];
}
for (int i = 1; i <= m; i++) {
int koji = gde[i];
last[koji] = i;
lift[i][0] = last[(koji == 1 ? n : koji - 1)];
}
for (int i = 1; i <= m; i++) {
for (int j = 1; j < 20; j++) lift[i][j] = lift[lift[i][j - 1]][j - 1];
}
for (int i = 1; i <= m; i++) niz[i] = nadji(i);
rq.napravi(m, niz);
while (q--) {
int l, r;
cin >> l >> r;
int rez = rq.query(l, r);
cout << (rez >= l ? 1 : 0);
}
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
There are N squares lining up in a row, numbered 1 through N from left to right. Initially, all squares are white. We also have N-1 painting machines, numbered 1 through N-1. When operated, Machine i paints Square i and i+1 black.
Snuke will operate these machines one by one. The order in which he operates them is represented by a permutation of (1, 2, ..., N-1), P, which means that the i-th operated machine is Machine P_i.
Here, the score of a permutation P is defined as the number of machines that are operated before all the squares are painted black for the first time, when the machines are operated in the order specified by P. Snuke has not decided what permutation P to use, but he is interested in the scores of possible permutations. Find the sum of the scores over all possible permutations for him. Since this can be extremely large, compute the sum modulo 10^9+7.
Constraints
* 2 \leq N \leq 10^6
Input
Input is given from Standard Input in the following format:
N
Output
Print the sum of the scores over all possible permutations, modulo 10^9+7.
Examples
Input
4
Output
16
Input
2
Output
1
Input
5
Output
84
Input
100000
Output
341429644
### Response
```cpp
#include <bits/stdc++.h>
template <class T>
T pow(T x, T n, T mod) {
T ret = 1;
while(n > 0) {
if ((n & 1) == 1) ret = (ret * x) % mod;
x = (x * x) % mod;
n >>= 1;
}
return ret;
}
template <class T>
T inverse(T x, T p) { return pow(x, p - 2, p); }
int main() {
long long n, ret = 0;
const auto mod = 1000000007ll;
std::cin >> n;
std::vector<long long> fact(n + 1), inv(n + 1);
fact[0] = 1;
for (auto i = 1ll; i <= n; i++) fact[i] = fact[i - 1] * i % mod;
inv[n] = inverse(fact[n], mod);
for (auto i = n; i > 0; i--) inv[i - 1] = inv[i] * i % mod;
auto pre = 0ll;
for (auto i = (n + 1) / 2; i < n; i++) {
auto t = fact[i - 1] * inv[n - 1 - i] % mod * inv[2 * i - n] % mod * fact[i] % mod * fact[n - 1 - i] % mod;
ret = (ret + (t - pre + mod) % mod * i) % mod;
pre = t;
}
std::cout << ret << std::endl;
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
Yasin has an array a containing n integers. Yasin is a 5 year old, so he loves ultimate weird things.
Yasin denotes weirdness of an array as maximum gcd(ai, aj) value among all 1 ≤ i < j ≤ n. For n ≤ 1 weirdness is equal to 0, gcd(x, y) is the greatest common divisor of integers x and y.
He also defines the ultimate weirdness of an array. Ultimate weirdness is <image> where f(i, j) is weirdness of the new array a obtained by removing all elements between i and j inclusive, so new array is [a1... ai - 1, aj + 1... an].
Since 5 year old boys can't code, Yasin asks for your help to find the value of ultimate weirdness of the given array a!
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the number of elements in a.
The next line contains n integers ai (1 ≤ ai ≤ 200 000), where the i-th number is equal to the i-th element of the array a. It is guaranteed that all ai are distinct.
Output
Print a single line containing the value of ultimate weirdness of the array a.
Example
Input
3
2 6 3
Output
6
Note
Consider the first sample.
* f(1, 1) is equal to 3.
* f(2, 2) is equal to 1.
* f(3, 3) is equal to 2.
* f(1, 2), f(1, 3) and f(2, 3) are equal to 0.
Thus the answer is 3 + 0 + 0 + 1 + 0 + 2 = 6.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5, maxm = 1e6, mx = 2e5 + 10;
int a[maxm], b[maxm];
long long s[maxm];
int c[maxn], fac[maxn];
long long h[maxn];
vector<int> v[maxn];
long long ans;
int n, i, j, k, L, R;
void update(int o, int l, int r) {
int m = (l + r) >> 1;
a[o] = 0;
s[o] = 0;
if (b[2 * o]) {
a[o] = max(a[o], b[2 * o]);
s[o] += (long long)(m - l) * b[2 * o];
} else {
a[o] = max(a[o], a[2 * o]);
s[o] += s[2 * o];
}
if (b[2 * o + 1]) {
a[o] = max(a[o], b[2 * o + 1]);
s[o] += (long long)(r - m) * b[2 * o + 1];
} else {
a[o] = max(a[o], a[2 * o + 1]);
s[o] += s[2 * o + 1];
}
}
void pushdown(int o) {
if (b[o]) {
b[2 * o] = b[o];
b[2 * o + 1] = b[o];
b[o] = 0;
}
}
void build(int o, int l, int r) {
if (l + 1 == r) {
a[o] = l;
s[o] = l;
return;
}
int m = (l + r) >> 1;
build(2 * o, l, m);
build(2 * o + 1, m, r);
update(o, l, r);
}
void modify(int o, int l, int r, int x, int y, int v) {
if (x >= y) return;
if (x <= l && r <= y) {
b[o] = v;
return;
}
pushdown(o);
int m = (l + r) >> 1;
if (x < m) modify(2 * o, l, m, x, y, v);
if (m < y) modify(2 * o + 1, m, r, x, y, v);
update(o, l, r);
}
bool ok(int o, int v) {
if (b[o])
return b[o] <= v;
else
return a[o] <= v;
}
void find(int o, int l, int r, int v, int &re) {
if (l + 1 == r) {
if (ok(o, v)) re = l;
return;
}
pushdown(o);
int m = (l + r) >> 1;
if (ok(2 * o, v)) {
re = m - 1;
find(2 * o + 1, m, r, v, re);
} else
find(2 * o, l, m, v, re);
update(o, l, r);
}
int main() {
scanf("%d", &n);
L = 1;
R = n + 1;
for (i = 2; i <= mx; i++)
if (!fac[i])
for (j = i; j <= mx; j += i) fac[j] = i;
for (int nn = 1; nn <= n; nn++) {
scanf("%d", &c[nn]);
int x = c[nn];
vector<int> d(1, 1);
while (x > 1) {
i = 0;
int y = fac[x];
int sz = d.size();
while (x % y == 0) {
x /= y;
int len = d.size();
for (j = i; j < len; j++) {
int z = d[j] * y;
d.push_back(z);
}
i += sz;
}
}
int len = d.size();
for (i = 0; i < len; i++) v[d[i]].push_back(nn);
}
build(1, L, R);
for (i = mx; i >= 0; i--) {
int len = v[i + 1].size();
if (len >= 2) {
int b1, b2, bk, bk_1;
bk = v[i + 1][len - 1];
bk_1 = v[i + 1][len - 2];
b1 = v[i + 1][0];
b2 = v[i + 1][1];
modify(1, L, R, v[i + 1][1] + 1, R, n + 1);
int re = 0;
find(1, L, R, v[i + 1][len - 1], re);
modify(1, L, R, v[i + 1][0] + 1, re + 1, v[i + 1][len - 1]);
re = 0;
find(1, L, R, v[i + 1][len - 2], re);
modify(1, L, R, 1, re + 1, v[i + 1][len - 2]);
}
h[i] = (long long)n * (n + 1) - s[1];
}
for (i = mx; i >= 1; i--) ans += (h[i] - h[i - 1]) * i;
printf("%I64d", ans);
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
Bob got a job as a system administrator in X corporation. His first task was to connect n servers with the help of m two-way direct connection so that it becomes possible to transmit data from one server to any other server via these connections. Each direct connection has to link two different servers, each pair of servers should have at most one direct connection. Y corporation, a business rival of X corporation, made Bob an offer that he couldn't refuse: Bob was asked to connect the servers in such a way, that when server with index v fails, the transmission of data between some other two servers becomes impossible, i.e. the system stops being connected. Help Bob connect the servers.
Input
The first input line contains 3 space-separated integer numbers n, m, v (3 ≤ n ≤ 105, 0 ≤ m ≤ 105, 1 ≤ v ≤ n), n — amount of servers, m — amount of direct connections, v — index of the server that fails and leads to the failure of the whole system.
Output
If it is impossible to connect the servers in the required way, output -1. Otherwise output m lines with 2 numbers each — description of all the direct connections in the system. Each direct connection is described by two numbers — indexes of two servers, linked by this direct connection. The servers are numbered from 1. If the answer is not unique, output any.
Examples
Input
5 6 3
Output
1 2
2 3
3 4
4 5
1 3
3 5
Input
6 100 1
Output
-1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long double epsilon = 1e-9;
int main() {
long long n, m, v;
cin >> n >> m >> v;
long long p = ((n - 1) * (n - 2)) / 2LL + 1;
if (m > p || m < n - 1) {
cout << -1 << endl;
return 0;
}
int other = 1;
if (v == 1) other = 2;
for (int i = 1; i <= n; i++) {
if (i == v)
continue;
else
cout << v << " " << i << endl;
}
m -= n - 1;
for (int i = 1; i <= n && m > 0; i++) {
if (i == v || i == other) continue;
for (int j = i + 1; j <= n && m > 0; j++) {
if (j == v || j == other || j == i) continue;
printf("%d %d\n", i, j);
m--;
}
}
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
Some people leave the lights at their workplaces on when they leave that is a waste of resources. As a hausmeister of DHBW, Sagheer waits till all students and professors leave the university building, then goes and turns all the lights off.
The building consists of n floors with stairs at the left and the right sides. Each floor has m rooms on the same line with a corridor that connects the left and right stairs passing by all the rooms. In other words, the building can be represented as a rectangle with n rows and m + 2 columns, where the first and the last columns represent the stairs, and the m columns in the middle represent rooms.
Sagheer is standing at the ground floor at the left stairs. He wants to turn all the lights off in such a way that he will not go upstairs until all lights in the floor he is standing at are off. Of course, Sagheer must visit a room to turn the light there off. It takes one minute for Sagheer to go to the next floor using stairs or to move from the current room/stairs to a neighboring room/stairs on the same floor. It takes no time for him to switch the light off in the room he is currently standing in. Help Sagheer find the minimum total time to turn off all the lights.
Note that Sagheer does not have to go back to his starting position, and he does not have to visit rooms where the light is already switched off.
Input
The first line contains two integers n and m (1 ≤ n ≤ 15 and 1 ≤ m ≤ 100) — the number of floors and the number of rooms in each floor, respectively.
The next n lines contains the building description. Each line contains a binary string of length m + 2 representing a floor (the left stairs, then m rooms, then the right stairs) where 0 indicates that the light is off and 1 indicates that the light is on. The floors are listed from top to bottom, so that the last line represents the ground floor.
The first and last characters of each string represent the left and the right stairs, respectively, so they are always 0.
Output
Print a single integer — the minimum total time needed to turn off all the lights.
Examples
Input
2 2
0010
0100
Output
5
Input
3 4
001000
000010
000010
Output
12
Input
4 3
01110
01110
01110
01110
Output
18
Note
In the first example, Sagheer will go to room 1 in the ground floor, then he will go to room 2 in the second floor using the left or right stairs.
In the second example, he will go to the fourth room in the ground floor, use right stairs, go to the fourth room in the second floor, use right stairs again, then go to the second room in the last floor.
In the third example, he will walk through the whole corridor alternating between the left and right stairs at each floor.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
string a[110];
int dp[2][110], c[2][110];
int main() {
int N, M, ans = 0;
cin >> N >> M;
for (int i = N; i > 0; i--) {
cin >> a[i];
}
for (int f = 1; f <= N; f++) {
for (int i = 0; i < M + 1 && a[f][i] == '0'; i++) c[0][f]++;
for (int i = M + 1; i > 0 && a[f][i] == '0'; i--) c[1][f]++;
}
dp[0][1] = 2 * (M + 1 - c[1][1]);
dp[1][1] = M + 1;
ans = (M + 1 - c[1][1]);
for (int f = 2; f <= N; f++) {
dp[0][f] =
min(1 + (M + 1 - c[1][f]) * 2 + dp[0][f - 1], 1 + M + dp[1][f - 1] + 1);
dp[1][f] =
min(1 + (M + 1 - c[0][f]) * 2 + dp[1][f - 1], 1 + M + dp[0][f - 1] + 1);
if (c[0][f] != M + 1 && c[1][f] != M + 1 && f != 1) {
ans = min(dp[0][f - 1] + 1 + (M + 1 - c[1][f]),
dp[1][f - 1] + 1 + (M + 1 - c[0][f]));
}
}
cout << ans << endl;
return 0;
}
``` |
### Prompt
Please create a solution in CPP 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 MAX_BUF_SIZE = 16384;
char BUFOR[MAX_BUF_SIZE];
int BUF_SIZE, BUF_POS;
char ZZZ;
int _MINUS;
const int MXN = 110;
const int C = 262144;
const int INF = 1000000001;
int n, m, k;
string str[MXN];
int a[MXN][MXN], b[MXN][MXN], c[MXN][MXN];
int main() {
cin >> n >> m >> k;
for (int i = (1); i <= (n); i++) {
cin >> str[i];
for (int j = (1); j <= (m); j++)
scanf("%d %d %d", &a[i][j], &b[i][j], &c[i][j]);
}
int res = 0;
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (n); j++)
if (i != j) {
vector<pair<int, int> > vec;
for (int o = (1); o <= (m); o++)
vec.push_back(make_pair(b[j][o] - a[i][o], c[i][o]));
sort((vec).begin(), (vec).end());
int resTmp = 0;
int cnt = k;
for (int o = ((int)(vec).size() - 1); o >= (0); o--) {
pair<int, int> p1 = vec[o];
if (p1.first > 0) {
while (p1.second && cnt > 0) {
p1.second--;
resTmp += p1.first;
cnt--;
}
}
}
res = max(res, resTmp);
}
printf("%d\n", res);
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
Wherever the destination is, whoever we meet, let's render this song together.
On a Cartesian coordinate plane lies a rectangular stage of size w × h, represented by a rectangle with corners (0, 0), (w, 0), (w, h) and (0, h). It can be seen that no collisions will happen before one enters the stage.
On the sides of the stage stand n dancers. The i-th of them falls into one of the following groups:
* Vertical: stands at (xi, 0), moves in positive y direction (upwards);
* Horizontal: stands at (0, yi), moves in positive x direction (rightwards).
<image>
According to choreography, the i-th dancer should stand still for the first ti milliseconds, and then start moving in the specified direction at 1 unit per millisecond, until another border is reached. It is guaranteed that no two dancers have the same group, position and waiting time at the same time.
When two dancers collide (i.e. are on the same point at some time when both of them are moving), they immediately exchange their moving directions and go on.
<image>
Dancers stop when a border of the stage is reached. Find out every dancer's stopping position.
Input
The first line of input contains three space-separated positive integers n, w and h (1 ≤ n ≤ 100 000, 2 ≤ w, h ≤ 100 000) — the number of dancers and the width and height of the stage, respectively.
The following n lines each describes a dancer: the i-th among them contains three space-separated integers gi, pi, and ti (1 ≤ gi ≤ 2, 1 ≤ pi ≤ 99 999, 0 ≤ ti ≤ 100 000), describing a dancer's group gi (gi = 1 — vertical, gi = 2 — horizontal), position, and waiting time. If gi = 1 then pi = xi; otherwise pi = yi. It's guaranteed that 1 ≤ xi ≤ w - 1 and 1 ≤ yi ≤ h - 1. It is guaranteed that no two dancers have the same group, position and waiting time at the same time.
Output
Output n lines, the i-th of which contains two space-separated integers (xi, yi) — the stopping position of the i-th dancer in the input.
Examples
Input
8 10 8
1 1 10
1 4 13
1 7 1
1 8 2
2 2 0
2 5 14
2 6 0
2 6 1
Output
4 8
10 5
8 8
10 6
10 2
1 8
7 8
10 6
Input
3 2 3
1 1 2
2 1 1
1 1 5
Output
1 3
2 1
1 3
Note
The first example corresponds to the initial setup in the legend, and the tracks of dancers are marked with different colours in the following figure.
<image>
In the second example, no dancers collide.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 88;
struct _dance {
int x, t, no;
};
struct _point {
int x, y;
};
int readint() {
int cur;
scanf("%d", &cur);
return cur;
}
bool cmp(_dance i, _dance j) { return i.x < j.x; }
queue<int> q[2 * maxn], pos[2 * maxn];
vector<_dance> x, y;
_point ans[maxn];
int main() {
int i;
int n = readint(), w = readint(), h = readint();
for (i = 0; i < n; i++) {
int g = readint(), p = readint(), t = readint();
if (g == 1)
x.push_back({p, t, i});
else
y.push_back({p, t, i});
}
sort(y.begin(), y.end(), cmp);
sort(x.begin(), x.end(), cmp);
for (i = (int)y.size() - 1; i >= 0; i--)
q[y[i].x - y[i].t + maxn].push(y[i].no),
pos[y[i].x - y[i].t + maxn].push(y[i].x);
for (i = 0; i < x.size(); i++) {
int cur = x[i].x - x[i].t + maxn, curno = x[i].no;
if (!q[cur].empty()) {
curno = q[cur].front();
q[cur].pop();
q[cur].push(x[i].no);
}
ans[curno] = {x[i].x, h};
}
for (i = 0; i < 2 * maxn; i++)
while (!q[i].empty())
ans[q[i].front()] = {w, pos[i].front()}, q[i].pop(), pos[i].pop();
for (i = 0; i < n; i++) printf("%d %d\n", ans[i].x, ans[i].y);
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
Yaroslav, Andrey and Roman love playing cubes. Sometimes they get together and play cubes for hours and hours!
Today they got together again and they are playing cubes. Yaroslav took unit cubes and composed them into an a × a × a cube, Andrey made a b × b × b cube and Roman made a c × c × c cube. After that the game was finished and the guys left. But later, Vitaly entered the room. He saw the cubes and wanted to make a cube as well. But what size should the cube be? Of course it should be a large cube with the side of length a + b + c. Besides, Vitaly decided to decompose the cubes built by Yaroslav, Andrey and Roman and compose his own large cube out of them. However, it turned out that the unit cubes he got from destroying the three cubes just weren't enough to make a large cube. We know that Vitaly was short of exactly n cubes. Vitaly got upset, demolished everything and left. As he was leaving, he met Petya and told him that there had been three cubes in the room and that he needed another n unit cubes to make his own large cube.
Petya entered the room and saw the messily scattered cubes. He wanted to make it neat and orderly again. But he only knows that there had been three cubes, made of small unit cubes and that Vitaly needed n more unit cubes to make a large one! Help Petya understand, how many ways of sizes a, b, c are there to restore Yaroslav's, Andrey's and Roman's cubes.
Input
The single line of the input contains integer n (1 ≤ n ≤ 1014). We know that all numbers a, b, c are positive integers.
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
In the single line print the required number of ways. If it turns out that there isn't a single way of suitable sizes of a, b, c, print 0.
Examples
Input
24
Output
1
Input
648
Output
7
Input
5
Output
0
Input
93163582512000
Output
39090
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int AB_MAX = 150005;
long long N, total = 0;
void add(long long a, long long b, long long c) {
assert(a <= b && b <= c);
if (a == b && b == c)
total++;
else if (a == b ^ b == c)
total += 3;
else
total += 6;
}
int main() {
cin >> N;
if (N % 3 != 0) {
cout << "0\n";
return 0;
}
N /= 3;
vector<int> factors;
for (int i = 1; i < AB_MAX; i++)
if (N % i == 0) factors.push_back(i);
for (long long a = 1; 8 * a * a * a <= N; a++)
for (int i = 0; i < (int)factors.size(); i++) {
long long b = factors[i] - a;
if (b < a) continue;
if (2 * b * b * b + 4 * a * b * b + 2 * a * a * b > N) break;
long long B = a + b, C = a * b - N / (a + b);
long long D = B * B - 4 * C;
long long S = sqrt(D + 0.5);
if (S * S != D) continue;
if ((S - B) % 2 != 0) continue;
long long c = (S - B) / 2;
if (c < b) continue;
assert(c * c + B * c + C == 0);
if (c >= b) add(a, b, c);
}
cout << total << '\n';
return 0;
}
``` |
### Prompt
Please formulate 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;
#pragma GCC optimize("O3")
long long fact(long long n) {
if (!n) return 1;
return n * fact(n - 1);
}
const int MAXN = 5e5 + 1000;
vector<int> cal(map<int, set<int>> idx, vector<vector<int>>& a, int n, int f) {
set<int> vis;
vector<int> res;
vector<int> rec(n);
while (res.size() < n - 1) {
int cur = -1, pos;
for (auto i = (1); i < (n + 1); i++)
if (idx[i].size() == 1 && i != f) {
cur = i;
pos = *idx[cur].begin();
break;
}
rec[n - 1 - res.size()] = pos;
if (cur == -1) return {};
vis.insert(cur);
res.push_back(cur);
for (auto x : a[pos]) idx[x].erase(pos);
}
res.push_back(f);
reverse((res).begin(), (res).end());
for (auto i = (1); i < (n); i++) {
auto v = a[rec[i]];
vector<int> vv(res.begin() + i - v.size() + 1, res.begin() + i + 1);
sort((vv).begin(), (vv).end());
if (vv != v) return {};
}
return res;
}
void solve(int tt) {
int n, tmp;
cin >> n;
vector<vector<int>> a(n - 1);
vector<int> k(n - 1);
map<int, set<int>> idx;
for (auto i = (0); i < (n - 1); i++) {
cin >> k[i];
for (auto j = (0); j < (k[i]); j++) {
cin >> tmp;
a[i].push_back(tmp);
idx[tmp].insert(i);
}
};
;
for (auto i = (1); i < (n + 1); i++) {
if (true || idx[i].size() == 1) {
auto res = cal(idx, a, n, i);
if (res.size() == 0) continue;
for (auto x : res) cout << x << ' ';
cout << endl;
return;
}
}
}
int main(int argc, char* argv[]) {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int T;
cin >> T;
for (int t = 1; t <= T; t++) {
solve(t);
};
return 0;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
Earlier, when there was no Internet, each bank had a lot of offices all around Bankopolis, and it caused a lot of problems. Namely, each day the bank had to collect cash from all the offices.
Once Oleg the bank client heard a dialogue of two cash collectors. Each day they traveled through all the departments and offices of the bank following the same route every day. The collectors started from the central department and moved between some departments or between some department and some office using special roads. Finally, they returned to the central department. The total number of departments and offices was n, the total number of roads was n - 1. In other words, the special roads system was a rooted tree in which the root was the central department, the leaves were offices, the internal vertices were departments. The collectors always followed the same route in which the number of roads was minimum possible, that is 2n - 2.
One of the collectors said that the number of offices they visited between their visits to offices a and then b (in the given order) is equal to the number of offices they visited between their visits to offices b and then a (in this order). The other collector said that the number of offices they visited between their visits to offices c and then d (in this order) is equal to the number of offices they visited between their visits to offices d and then c (in this order). The interesting part in this talk was that the shortest path (using special roads only) between any pair of offices among a, b, c and d passed through the central department.
Given the special roads map and the indexes of offices a, b, c and d, determine if the situation described by the collectors was possible, or not.
Input
The first line contains single integer n (5 ≤ n ≤ 5000) — the total number of offices and departments. The departments and offices are numbered from 1 to n, the central office has index 1.
The second line contains four integers a, b, c and d (2 ≤ a, b, c, d ≤ n) — the indexes of the departments mentioned in collector's dialogue. It is guaranteed that these indexes are offices (i.e. leaves of the tree), not departments. It is guaranteed that the shortest path between any pair of these offices passes through the central department.
On the third line n - 1 integers follow: p2, p3, ..., pn (1 ≤ pi < i), where pi denotes that there is a special road between the i-th office or department and the pi-th department.
Please note the joint enumeration of departments and offices.
It is guaranteed that the given graph is a tree. The offices are the leaves, the departments are the internal vertices.
Output
If the situation described by the cash collectors was possible, print "YES". Otherwise, print "NO".
Examples
Input
5
2 3 4 5
1 1 1 1
Output
YES
Input
10
3 8 9 10
1 2 2 2 2 2 1 1 1
Output
NO
Input
13
13 12 9 7
1 1 1 1 5 5 2 2 2 3 3 4
Output
YES
Note
In the first example the following collector's route was possible: <image>. We can note that between their visits to offices a and b the collectors visited the same number of offices as between visits to offices b and a; the same holds for c and d (the collectors' route is infinite as they follow it each day).
In the second example there is no route such that between their visits to offices c and d the collectors visited the same number of offices as between visits to offices d and c. Thus, there situation is impossible.
In the third example one of the following routes is: <image>.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5005;
int n;
int a, b, c, d;
vector<int> E[maxn];
bool ablink[maxn];
bool cdlink[maxn];
vector<int> ab;
vector<int> cd;
void addEdge(int u, int v) {
E[u].push_back(v);
E[v].push_back(u);
}
bool dfs(int u, int pre, int target) {
if (u == target) {
if (target == b) {
ablink[u] = 1;
}
if (target == d) {
cdlink[u] = 1;
}
return 1;
}
int sz = E[u].size();
for (int i = 0; i < sz; i++) {
int v = E[u][i];
if (v == pre) continue;
if (dfs(v, u, target)) {
if (target == b) {
ablink[u] = 1;
}
if (target == d) {
cdlink[u] = 1;
}
return 1;
}
}
return 0;
}
int dfsab(int u, int pre) {
int sz = E[u].size();
int re = (sz == 1 && u != 1);
for (int i = 0; i < sz; i++) {
int v = E[u][i];
if (v == pre) continue;
int tmp = dfsab(v, u);
re += tmp;
if (ablink[u] && !ablink[v]) {
ab.push_back(tmp);
}
}
return re;
}
int dfscd(int u, int pre) {
int sz = E[u].size();
int re = (sz == 1 && u != 1);
for (int i = 0; i < sz; i++) {
int v = E[u][i];
if (v == pre) continue;
int tmp = dfscd(v, u);
re += tmp;
if (cdlink[u] && !cdlink[v]) {
cd.push_back(tmp);
}
}
return re;
}
bool dpab[2][maxn * 2];
bool dpcd[2][maxn * 2];
int main() {
cin >> n;
cin >> a >> b >> c >> d;
for (int i = 2; i <= n; i++) {
int p;
cin >> p;
addEdge(i, p);
}
dfs(a, 0, b);
dfs(c, 0, d);
dfsab(a, 0);
dfscd(c, 0);
bool ok = 1;
int cur = 0;
int pre = 1;
dpab[cur][n] = 1;
for (int x : ab) {
swap(cur, pre);
memset(dpab[cur], 0, sizeof(dpab[cur]));
for (int i = 0; i < n * 2; i++) {
if (dpab[pre][i]) {
dpab[cur][i - x] = 1;
dpab[cur][i + x] = 1;
}
}
}
ok &= dpab[cur][n];
dpcd[cur][n] = 1;
for (int x : cd) {
swap(cur, pre);
memset(dpcd[cur], 0, sizeof(dpcd[cur]));
for (int i = 0; i < n * 2; i++) {
if (dpcd[pre][i]) {
dpcd[cur][i - x] = 1;
dpcd[cur][i + x] = 1;
}
}
}
ok &= dpcd[cur][n];
if (ok) {
puts("YES");
} else {
puts("NO");
}
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
Valera is a little boy. Yesterday he got a huge Math hometask at school, so Valera didn't have enough time to properly learn the English alphabet for his English lesson. Unfortunately, the English teacher decided to have a test on alphabet today. At the test Valera got a square piece of squared paper. The length of the side equals n squares (n is an odd number) and each unit square contains some small letter of the English alphabet.
Valera needs to know if the letters written on the square piece of paper form letter "X". Valera's teacher thinks that the letters on the piece of paper form an "X", if:
* on both diagonals of the square paper all letters are the same;
* all other squares of the paper (they are not on the diagonals) contain the same letter that is different from the letters on the diagonals.
Help Valera, write the program that completes the described task for him.
Input
The first line contains integer n (3 ≤ n < 300; n is odd). Each of the next n lines contains n small English letters — the description of Valera's paper.
Output
Print string "YES", if the letters on the paper form letter "X". Otherwise, print string "NO". Print the strings without quotes.
Examples
Input
5
xooox
oxoxo
soxoo
oxoxo
xooox
Output
NO
Input
3
wsw
sws
wsw
Output
YES
Input
3
xpx
pxp
xpe
Output
NO
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, flag = 0;
cin >> n;
char a[n][n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> a[i][j];
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i == j) {
continue;
} else if (i + j + 1 == n) {
continue;
} else if (a[0][1] != a[i][j]) {
flag = 1;
break;
} else {
continue;
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i != j && i + j + 1 != n) {
continue;
} else if (a[0][0] != a[i][j]) {
flag = 1;
break;
} else {
continue;
}
}
}
if (a[0][0] == a[0][1]) {
flag = 1;
}
if (flag == 1) {
cout << "NO";
} else {
cout << "YES";
}
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
Valery is very interested in magic. Magic attracts him so much that he sees it everywhere. He explains any strange and weird phenomenon through intervention of supernatural forces. But who would have thought that even in a regular array of numbers Valera manages to see something beautiful and magical.
Valera absolutely accidentally got a piece of ancient parchment on which an array of numbers was written. He immediately thought that the numbers in this array were not random. As a result of extensive research Valera worked out a wonderful property that a magical array should have: an array is defined as magic if its minimum and maximum coincide.
He decided to share this outstanding discovery with you, but he asks you for help in return. Despite the tremendous intelligence and wit, Valera counts very badly and so you will have to complete his work. All you have to do is count the number of magical subarrays of the original array of numbers, written on the parchment. Subarray is defined as non-empty sequence of consecutive elements.
Input
The first line of the input data contains an integer n (1 ≤ n ≤ 105). The second line contains an array of original integers a1, a2, ..., an ( - 109 ≤ ai ≤ 109).
Output
Print on the single line the answer to the problem: the amount of subarrays, which are magical.
Please do not use the %lld specificator to read or write 64-bit numbers in C++. It is recommended to use cin, cout streams (you can also use the %I64d specificator).
Examples
Input
4
2 1 1 4
Output
5
Input
5
-2 -2 -2 0 1
Output
8
Note
Notes to sample tests:
Magical subarrays are shown with pairs of indices [a;b] of the beginning and the end.
In the first sample: [1;1], [2;2], [3;3], [4;4], [2;3].
In the second sample: [1;1], [2;2], [3;3], [4;4], [5;5], [1;2], [2;3], [1;3].
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int arr[100009];
int main() {
long long int n;
cin >> n;
long long int arr[n];
for (long long int i = 0; i < n; i++) cin >> arr[i];
long long int beg = arr[0];
long long int ct = 0;
long long int ans = 0;
for (long long int i = 0; i < n; i++) {
if (arr[i] == beg)
ct++;
else {
ans += (ct * (ct + 1)) / 2;
ct = 1;
beg = arr[i];
}
}
ans += (ct * (ct + 1)) / 2;
cout << ans;
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
Consider car trips in a country where there is no friction. Cars in this country do not have engines. Once a car started to move at a speed, it keeps moving at the same speed. There are acceleration devices on some points on the road, where a car can increase or decrease its speed by 1. It can also keep its speed there. Your job in this problem is to write a program which determines the route with the shortest time to travel from a starting city to a goal city.
There are several cities in the country, and a road network connecting them. Each city has an acceleration device. As mentioned above, if a car arrives at a city at a speed v , it leaves the city at one of v - 1, v , or v + 1. The first road leaving the starting city must be run at the speed 1. Similarly, the last road arriving at the goal city must be run at the speed 1.
The starting city and the goal city are given. The problem is to find the best route which leads to the goal city going through several cities on the road network. When the car arrives at a city, it cannot immediately go back the road it used to reach the city. No U-turns are allowed. Except this constraint, one can choose any route on the road network. It is allowed to visit the same city or use the same road multiple times. The starting city and the goal city may be visited during the trip.
For each road on the network, its distance and speed limit are given. A car must run a road at a speed less than or equal to its speed limit. The time needed to run a road is the distance divided by the speed. The time needed within cities including that for acceleration or deceleration should be ignored.
Input
The input consists of multiple datasets, each in the following format.
> n m
> s g
> x 1 y 1 d 1 c 1
> ...
> xm ym dm cm
>
Every input item in a dataset is a non-negative integer. Input items in the same line are separated by a space.
The first line gives the size of the road network. n is the number of cities in the network. You can assume that the number of cities is between 2 and 30, inclusive. m is the number of roads between cities, which may be zero.
The second line gives the trip. s is the city index of the starting city. g is the city index of the goal city. s is not equal to g . You can assume that all city indices in a dataset (including the above two) are between 1 and n , inclusive.
The following m lines give the details of roads between cities. The i -th road connects two cities with city indices xi and yi , and has a distance di (1 ≤ i ≤ m ). You can assume that the distance is between 1 and 100, inclusive. The speed limit of the road is specified by ci . You can assume that the speed limit is between 1 and 30, inclusive.
No two roads connect the same pair of cities. A road never connects a city with itself. Each road can be traveled in both directions.
The last dataset is followed by a line containing two zeros (separated by a space).
Output
For each dataset in the input, one line should be output as specified below. An output line should not contain extra characters such as spaces.
If one can travel from the starting city to the goal city, the time needed for the best route (a route with the shortest time) should be printed. The answer should not have an error greater than 0.001. You may output any number of digits after the decimal point, provided that the above accuracy condition is satisfied.
If it is impossible to reach the goal city, the string "`unreachable`" should be printed. Note that all the letters of "`unreachable`" are in lowercase.
Sample Input
2 0
1 2
5 4
1 5
1 2 1 1
2 3 2 2
3 4 2 2
4 5 1 1
6 6
1 6
1 2 2 1
2 3 2 1
3 6 2 1
1 4 2 30
4 5 3 30
5 6 2 30
6 7
1 6
1 2 1 30
2 3 1 30
3 1 1 30
3 4 100 30
4 5 1 30
5 6 1 30
6 4 1 30
0 0
Output for the Sample Input
unreachable
4.00000
5.50000
11.25664
Example
Input
2 0
1 2
5 4
1 5
1 2 1 1
2 3 2 2
3 4 2 2
4 5 1 1
6 6
1 6
1 2 2 1
2 3 2 1
3 6 2 1
1 4 2 30
4 5 3 30
5 6 2 30
6 7
1 6
1 2 1 30
2 3 1 30
3 1 1 30
3 4 100 30
4 5 1 30
5 6 1 30
6 4 1 30
0 0
Output
unreachable
4.00000
5.50000
11.25664
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
struct Edge {
int to, dist, cap;
Edge(int t, int d, int c) {
to = t;
dist = d;
cap = c;
}
};
struct State {
int pos, prev, v;
double time;
State(int p, int pr, int v_, double t) {
pos = p;
prev = pr;
v = v_;
time = t;
}
bool operator<(const State& right) const {
return time > right.time;
}
};
double min_time[32][32][32];
bool visited[32][32][32];
int main() {
while(true) {
int n, m;
cin >> n >> m;
if (n == 0) break;
int start, goal;
cin >> start >> goal;
start--;
goal--;
vector<vector<Edge>> G(n);
for (int i = 0; i<m; i++) {
int x, y, d, c;
cin >> x >> y >> d >> c;
x--;
y--;
G[x].emplace_back(y, d, c);
G[y].emplace_back(x, d, c);
}
memset(visited, 0, sizeof(visited));
priority_queue<State> que;
que.emplace(start, start, 0, 0);
visited[start][start][0] = true;
min_time[start][start][0] = 0;
double ans = -1;
while (!que.empty()) {
auto s = que.top();
que.pop();
if (min_time[s.pos][s.prev][s.v] < s.time) continue;
if (s.pos == goal && s.v == 1) {
ans = s.time;
break;
}
for (int dv = -1; dv <= 1; dv++) {
int nv = s.v + dv;
for (auto& e : G[s.pos]) {
if (e.to == s.prev) continue;
if (nv < 1 || e.cap < nv) continue;
double nt = s.time + double(e.dist) / nv;
if (!visited[e.to][s.pos][nv] || min_time[e.to][s.pos][nv] > nt) {
visited[e.to][s.pos][nv] = true;
min_time[e.to][s.pos][nv] = nt;
que.emplace(e.to, s.pos, nv, nt);
}
}
}
}
if (ans < 0) {
cout << "unreachable" << endl;
} else {
printf("%.5f\n", ans);
}
}
return 0;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
You have a rooted tree consisting of n vertices. Let's number them with integers from 1 to n inclusive. The root of the tree is the vertex 1. For each i > 1 direct parent of the vertex i is pi. We say that vertex i is child for its direct parent pi.
You have initially painted all the vertices with red color. You like to repaint some vertices of the tree. To perform painting you use the function paint that you call with the root of the tree as an argument. Here is the pseudocode of this function:
count = 0 // global integer variable
rnd() { // this function is used in paint code
return 0 or 1 equiprobably
}
paint(s) {
if (count is even) then paint s with white color
else paint s with black color
count = count + 1
if rnd() = 1 then children = [array of vertex s children in ascending order of their numbers]
else children = [array of vertex s children in descending order of their numbers]
for child in children { // iterating over children array
if rnd() = 1 then paint(child) // calling paint recursively
}
}
As a result of this function, some vertices may change their colors to white or black and some of them may remain red.
Your task is to determine the number of distinct possible colorings of the vertices of the tree. We will assume that the coloring is possible if there is a nonzero probability to get this coloring with a single call of paint(1). We assume that the colorings are different if there is a pair of vertices that are painted with different colors in these colorings. Since the required number may be very large, find its remainder of division by 1000000007 (109 + 7).
Input
The first line contains a single integer n (2 ≤ n ≤ 105) — the number of vertexes in the tree.
The second line contains n - 1 integers p2, p3, ..., pn (1 ≤ pi < i). Number pi is the parent of vertex i.
Output
Print a single integer — the answer to the problem modulo 1000000007 (109 + 7)
Examples
Input
4
1 2 1
Output
8
Input
3
1 1
Output
5
Note
All possible coloring patterns of the first sample are given below.
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5;
long long dp[maxn + 10][2], mod = 1e9 + 7;
int n;
vector<int> vect[maxn + 10];
long long go(int x, int p) {
if (vect[x].size() == 0) {
dp[x][1] = 1;
dp[x][0] = 0;
return dp[x][p];
}
if (dp[x][p] != -1) return dp[x][p];
dp[x][1] = 1;
dp[x][0] = 0;
sort(vect[x].begin(), vect[x].end());
for (int i = 0; i < vect[x].size(); i++) {
int id = vect[x][i];
long long pom0 = (dp[x][1] * go(id, 1) + dp[x][0] * go(id, 0)) % mod;
long long pom1 = (dp[x][1] * go(id, 0) + dp[x][0] * go(id, 1)) % mod;
dp[x][0] = (dp[x][0] + pom0) % mod;
dp[x][1] = (dp[x][1] + pom1) % mod;
}
dp[x][0] = (dp[x][0] * 2) % mod;
dp[x][1] = (dp[x][1] * 2) % mod;
long long dp2[2][2];
dp2[0][0] = dp2[1][0] = 1;
dp2[0][1] = dp2[1][1] = 0;
for (int i = 0; i < vect[x].size(); i++) {
int id = vect[x][i];
long long pom = dp2[0][0];
dp2[0][0] = (dp2[0][0] + dp2[0][1] * go(id, 0)) % mod;
dp2[0][1] = (dp2[0][1] + pom * go(id, 0)) % mod;
pom = dp2[1][0];
dp2[1][0] = (dp2[1][0] + dp2[1][1] * go(id, 1)) % mod;
dp2[1][1] = (dp2[1][1] + pom * go(id, 1)) % mod;
}
dp[x][1] = (dp[x][1] - dp2[0][0] - dp2[0][1] + mod + mod) % mod;
dp[x][0] = (dp[x][0] - dp2[1][1] + mod) % mod;
return dp[x][p];
}
int main() {
scanf("%d", &n);
for (int i = 2; i <= n; i++) {
int p;
scanf("%d", &p);
vect[p].push_back(i);
}
memset(dp, -1, sizeof(dp));
printf("%lld\n", (go(1, 0) + go(1, 1)) % mod);
return 0;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
In order to participate in the Asian Regional Qualifiers of the International Collegiate Programming Contest held every year in Japan, we must break through the strict domestic qualifiers.
Even though it is a university competition, multiple teams from one school will participate. Therefore, the following selection rules apply to the selection of breakthrough teams so that as many schools as possible can participate in the Asian Qualifiers:
Let A be the team and apply the following rules in order of best grade:
* Rule 1:
If the number of selected teams at that time is less than 10:
If the number of teams in the same affiliation as A and selected at that time is less than 3, A will be selected.
* Rule 2:
If the number of selected teams at that time is less than 20:
If the number of teams in the same affiliation as A and selected at that time is less than 2, A will be selected.
* Rule 3:
If the number of selected teams at that time is less than 26:
If there is no team in the same affiliation as A and selected at that time, A will be selected.
In addition, the order of grades is determined by the following rules:
* The team that solved more problems will be ranked higher.
* If the number of problems solved is the same, the team with the smaller penalty will be ranked higher.
Enter the ID (integer), affiliation (integer), number of correct answers (integer), and penalty (integer) of each team, and create a program that outputs the ID of the selected team in the order of selection. Please note that teams are not always given in order of grade, so selection rules must be applied after ranking.
In this question, if there is a team with the same number of correct answers and the same penalty, the one with the smaller ID will be ranked higher.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
n (number of teams: integer)
I1 U1 A1 P1 (ID of first team, affiliation, number of correct answers, penalty: 4 integers separated by blanks)
I2 U2 A2 P2 (ID of second team, affiliation, number of correct answers, penalty: 4 integers separated by blanks)
..
..
In Un An Pn (ID of nth team, affiliation, number of correct answers, penalty: 4 integers separated by blanks)
n is 300 or less, and Ii and Ui are 1 or more and 1000 or less. You can assume that there are no teams with the same ID in a dataset.
Ai should be 10 or less and Pi should be 100,000 or less.
When n is 0, it is the end of input.
Output
For each dataset, output the IDs of the selected teams in the order in which they were selected. Please output one ID on one line.
Example
Input
6
1 1 6 200
2 1 6 300
3 1 6 400
4 2 5 1200
5 1 5 1400
6 3 4 800
3
777 1 5 300
808 2 4 20
123 3 6 500
2
2 1 3 100
1 1 3 100
0
Output
1
2
3
4
6
123
777
808
1
2
### Response
```cpp
#include <bits/stdc++.h>
#define rep(i, a, n) for(int i = a; i < n; i++)
#define repb(i, a, b) for(int i = a; i >= b; i--)
#define all(a) a.begin(), a.end()
//#define int long long
using namespace std;
struct team{
int id, univ, ac, pen;
//team(int id, int univ, int ac, int pen):id(id), univ(univ), ac(ac), pen(pen){}
};
bool cmp(team d1, team d2){
if(d1.ac != d2.ac){
return d1.ac > d2.ac;
}else if(d1.pen != d2.pen){
return d1.pen < d2.pen;
}else{
return d1.id < d2.id;
}
}
signed main(){
int n;
while(cin >> n, n){
vector<team> d(n);
rep(i, 0, n){
cin >> d[i].id >> d[i].univ >> d[i].ac >> d[i].pen;
}
sort(all(d), cmp);
/*rep(i, 0, d.size()){
cout << ' ' << d[i].id << endl;
}*/
map<int, int> mp;
set<int> st;
int cnt = 0;
vector<int> ans;
rep(i, 0, n){
if(cnt >= 10) break;
if(mp[d[i].univ] <= 2 && !st.count(d[i].id)){
ans. push_back(d[i].id);
st.insert(d[i].id);
mp[d[i].univ]++;
cnt++;
}
}
rep(i, 0, n){
if(cnt >= 20) break;
if(mp[d[i].univ] <= 1 && !st.count(d[i].id)){
ans. push_back(d[i].id);
st.insert(d[i].id);
mp[d[i].univ]++;
cnt++;
}
}
rep(i, 0, n){
if(cnt >= 26) break;
if(mp[d[i].univ] == 0 && !st.count(d[i].id)){
ans. push_back(d[i].id);
st.insert(d[i].id);
mp[d[i].univ]++;
cnt++;
}
}
rep(i, 0, cnt){
cout << ans[i] << endl;
}
}
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
Salem gave you n sticks with integer positive lengths a_1, a_2, …, a_n.
For every stick, you can change its length to any other positive integer length (that is, either shrink or stretch it). The cost of changing the stick's length from a to b is |a - b|, where |x| means the absolute value of x.
A stick length a_i is called almost good for some integer t if |a_i - t| ≤ 1.
Salem asks you to change the lengths of some sticks (possibly all or none), such that all sticks' lengths are almost good for some positive integer t and the total cost of changing is minimum possible. The value of t is not fixed in advance and you can choose it as any positive integer.
As an answer, print the value of t and the minimum cost. If there are multiple optimal choices for t, print any of them.
Input
The first line contains a single integer n (1 ≤ n ≤ 1000) — the number of sticks.
The second line contains n integers a_i (1 ≤ a_i ≤ 100) — the lengths of the sticks.
Output
Print the value of t and the minimum possible cost. If there are multiple optimal choices for t, print any of them.
Examples
Input
3
10 1 4
Output
3 7
Input
5
1 1 2 2 3
Output
2 0
Note
In the first example, we can change 1 into 2 and 10 into 4 with cost |1 - 2| + |10 - 4| = 1 + 6 = 7 and the resulting lengths [2, 4, 4] are almost good for t = 3.
In the second example, the sticks lengths are already almost good for t = 2, so we don't have to do anything.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 500000;
const int INF = 2e9;
const int mod = 10007;
int n, a[1005], t, po;
int ant;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
ant = 100000000000;
for (t = 1; t <= 105; t++) {
int ret = 0;
for (int i = 0; i < n; i++) {
if (a[i] < t - 1) {
ret += abs(a[i] - t + 1);
} else if (a[i] > t + 1) {
ret += abs(a[i] - t - 1);
}
}
if (ret < ant) {
ant = ret;
po = t;
}
}
printf("%d %d\n", po, ant);
return 0;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
You are given a string s and should process m queries. Each query is described by two 1-based indices li, ri and integer ki. It means that you should cyclically shift the substring s[li... ri] ki times. The queries should be processed one after another in the order they are given.
One operation of a cyclic shift (rotation) is equivalent to moving the last character to the position of the first character and shifting all other characters one position to the right.
For example, if the string s is abacaba and the query is l1 = 3, r1 = 6, k1 = 1 then the answer is abbacaa. If after that we would process the query l2 = 1, r2 = 4, k2 = 2 then we would get the string baabcaa.
Input
The first line of the input contains the string s (1 ≤ |s| ≤ 10 000) in its initial state, where |s| stands for the length of s. It contains only lowercase English letters.
Second line contains a single integer m (1 ≤ m ≤ 300) — the number of queries.
The i-th of the next m lines contains three integers li, ri and ki (1 ≤ li ≤ ri ≤ |s|, 1 ≤ ki ≤ 1 000 000) — the description of the i-th query.
Output
Print the resulting string s after processing all m queries.
Examples
Input
abacaba
2
3 6 1
1 4 2
Output
baabcaa
Note
The sample is described in problem statement.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
char s[N];
char ss[N];
int main() {
scanf(" %s", s);
int n = strlen(s);
int m;
scanf("%d", &m);
while (m--) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
a--;
b--;
int num = b - a + 1;
for (int i = a; i <= b; i++) {
ss[(((i - a) + c) % num) + a] = s[i];
}
for (int i = a; i <= b; i++) {
s[i] = ss[i];
}
}
for (int i = 0; i < n; i++) {
printf("%c", s[i]);
}
return 0;
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
Robot Doc is located in the hall, with n computers stand in a line, numbered from left to right from 1 to n. Each computer contains exactly one piece of information, each of which Doc wants to get eventually. The computers are equipped with a security system, so to crack the i-th of them, the robot needs to collect at least ai any pieces of information from the other computers. Doc can hack the computer only if he is right next to it.
The robot is assembled using modern technologies and can move along the line of computers in either of the two possible directions, but the change of direction requires a large amount of resources from Doc. Tell the minimum number of changes of direction, which the robot will have to make to collect all n parts of information if initially it is next to computer with number 1.
It is guaranteed that there exists at least one sequence of the robot's actions, which leads to the collection of all information. Initially Doc doesn't have any pieces of information.
Input
The first line contains number n (1 ≤ n ≤ 1000). The second line contains n non-negative integers a1, a2, ..., an (0 ≤ ai < n), separated by a space. It is guaranteed that there exists a way for robot to collect all pieces of the information.
Output
Print a single number — the minimum number of changes in direction that the robot will have to make in order to collect all n parts of information.
Examples
Input
3
0 2 0
Output
1
Input
5
4 2 3 0 1
Output
3
Input
7
0 3 1 0 5 2 6
Output
2
Note
In the first sample you can assemble all the pieces of information in the optimal manner by assembling first the piece of information in the first computer, then in the third one, then change direction and move to the second one, and then, having 2 pieces of information, collect the last piece.
In the second sample to collect all the pieces of information in the optimal manner, Doc can go to the fourth computer and get the piece of information, then go to the fifth computer with one piece and get another one, then go to the second computer in the same manner, then to the third one and finally, to the first one. Changes of direction will take place before moving from the fifth to the second computer, then from the second to the third computer, then from the third to the first computer.
In the third sample the optimal order of collecting parts from computers can look like that: 1->3->4->6->2->5->7.
### Response
```cpp
#include <bits/stdc++.h>
int main() {
int n;
int ai[1001];
int infpiece, l, l1;
int dirchg;
while (1 == scanf("%d", &n)) {
for (l = 1; l <= n; scanf("%d", &ai[l]), l++)
;
for (l = 0, infpiece = 0, dirchg = 0; l < n;) {
for (l1 = 1; l1 <= n; l1++) {
if (ai[l1] >= 0 && infpiece >= ai[l1]) {
ai[l1] = -1;
infpiece++;
l++;
}
}
if (l < n)
dirchg++;
else
break;
for (l1 = n; l1; l1--) {
if (ai[l1] >= 0 && infpiece >= ai[l1]) {
ai[l1] = -1;
infpiece++;
l++;
}
}
if (l < n)
dirchg++;
else
break;
}
printf("%d\n", dirchg);
}
return 0;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
There are n blocks arranged in a row and numbered from left to right, starting from one. Each block is either black or white.
You may perform the following operation zero or more times: choose two adjacent blocks and invert their colors (white block becomes black, and vice versa).
You want to find a sequence of operations, such that they make all the blocks having the same color. You don't have to minimize the number of operations, but it should not exceed 3 ⋅ n. If it is impossible to find such a sequence of operations, you need to report it.
Input
The first line contains one integer n (2 ≤ n ≤ 200) — the number of blocks.
The second line contains one string s consisting of n characters, each character is either "W" or "B". If the i-th character is "W", then the i-th block is white. If the i-th character is "B", then the i-th block is black.
Output
If it is impossible to make all the blocks having the same color, print -1.
Otherwise, print an integer k (0 ≤ k ≤ 3 ⋅ n) — the number of operations. Then print k integers p_1, p_2, ..., p_k (1 ≤ p_j ≤ n - 1), where p_j is the position of the left block in the pair of blocks that should be affected by the j-th operation.
If there are multiple answers, print any of them.
Examples
Input
8
BWWWWWWB
Output
3
6 2 4
Input
4
BWBB
Output
-1
Input
5
WWWWW
Output
0
Input
3
BWB
Output
2
2 1
Note
In the first example, it is possible to make all blocks black in 3 operations. Start with changing blocks 6 and 7, so the sequence is "BWWWWBBB". Then change blocks 2 and 3, so the sequence is "BBBWWBB". And finally, change blocks 4 and 5, so all blocks are black.
It is impossible to make all colors equal in the second example.
All blocks are already white in the third example.
In the fourth example it is possible to make all blocks white in two operations: first operation is to change blocks 2 and 3 (so the sequence is "BBW"), and then change blocks 1 and 2 (so all blocks are white).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s;
int n;
cin >> n;
cin >> s;
for (auto &c : s) c = (c == 'B') ? 1 : 0;
for (int col = 0; col < 2; col++) {
string t = s;
vector<int> ans;
for (int i = 0; i + 1 < n; i++) {
if (t[i] != col) {
t[i] = col;
t[i + 1] ^= 1;
ans.push_back(i);
}
}
if (t.back() == col) {
cout << ans.size() << endl;
for (auto x : ans) cout << x + 1 << ' ';
return 0;
}
}
cout << -1 << endl;
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
Marmot found a row with n pillars. The i-th pillar has the height of hi meters. Starting from one pillar i1, Marmot wants to jump on the pillars i2, ..., ik. (1 ≤ i1 < i2 < ... < ik ≤ n). From a pillar i Marmot can jump on a pillar j only if i < j and |hi - hj| ≥ d, where |x| is the absolute value of the number x.
Now Marmot is asking you find out a jump sequence with maximal length and print it.
Input
The first line contains two integers n and d (1 ≤ n ≤ 105, 0 ≤ d ≤ 109).
The second line contains n numbers h1, h2, ..., hn (1 ≤ hi ≤ 1015).
Output
The first line should contain one integer k, the maximal length of a jump sequence.
The second line should contain k integers i1, i2, ..., ik (1 ≤ i1 < i2 < ... < ik ≤ n), representing the pillars' indices from the maximal length jump sequence.
If there is more than one maximal length jump sequence, print any.
Examples
Input
5 2
1 3 6 7 4
Output
4
1 2 3 5
Input
10 3
2 1 3 6 9 11 7 3 20 18
Output
6
1 4 6 7 8 9
Note
In the first example Marmot chooses the pillars 1, 2, 3, 5 with the heights 1, 3, 6, 4. Another jump sequence of length 4 is 1, 2, 4, 5.
### Response
```cpp
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
const int maxn = 100000 + 100;
int n, lim, m, d[maxn], pre[maxn];
long long a[maxn], b[maxn];
int mx[maxn << 2], pos[maxn << 2];
void pushup(int rt) {
if (mx[(rt << 1)] >= mx[((rt << 1) | 1)])
mx[rt] = mx[(rt << 1)], pos[rt] = pos[(rt << 1)];
else
mx[rt] = mx[((rt << 1) | 1)], pos[rt] = pos[((rt << 1) | 1)];
}
void insert(int x, int p, int v, int l, int r, int rt) {
if (l == r) {
if (v > mx[rt]) {
mx[rt] = v;
pos[rt] = p;
}
return;
}
int mid = l + r >> 1;
if (x <= mid)
insert(x, p, v, l, mid, (rt << 1));
else
insert(x, p, v, mid + 1, r, ((rt << 1) | 1));
pushup(rt);
}
pair<int, int> query(int L, int R, int l, int r, int rt) {
if (L <= l && R >= r) return pair<int, int>(mx[rt], pos[rt]);
int mid = l + r >> 1;
pair<int, int> ans(0, 0);
if (L <= mid) ans = max(ans, query(L, R, l, mid, (rt << 1)));
if (R > mid) ans = max(ans, query(L, R, mid + 1, r, ((rt << 1) | 1)));
return ans;
}
void print(int x) {
if (pre[x]) {
print(pre[x]);
putchar(' ');
}
printf("%d", x);
}
int main() {
scanf("%d%d", &m, &lim);
for (int i = 1; i <= m; i++) {
scanf("%I64d", a + i);
b[i] = a[i];
}
sort(b + 1, b + 1 + m);
n = unique(b + 1, b + 1 + m) - b - 1;
int len = 0, ans;
for (int i = 1; i <= m; i++) {
int L = upper_bound(b + 1, b + 1 + n, a[i] - lim) - b;
int R = lower_bound(b + 1, b + 1 + n, a[i] + lim) - b;
d[i] = -1;
if (L > 1) {
pair<int, int> t = query(1, L - 1, 1, n, 1);
if (t.first + 1 > d[i]) d[i] = t.first + 1, pre[i] = t.second;
}
if (R <= n) {
pair<int, int> t = query(R, n, 1, n, 1);
if (t.first + 1 > d[i]) d[i] = t.first + 1, pre[i] = t.second;
}
int k = lower_bound(b + 1, b + 1 + n, a[i]) - b;
insert(k, i, d[i], 1, n, 1);
if (d[i] > len) len = d[ans = i];
}
printf("%d\n", len);
print(ans);
puts("");
return 0;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
We have two indistinguishable pieces placed on a number line. Both pieces are initially at coordinate 0. (They can occupy the same position.)
We can do the following two kinds of operations:
* Choose a piece and move it to the right (the positive direction) by 1.
* Move the piece with the smaller coordinate to the position of the piece with the greater coordinate. If two pieces already occupy the same position, nothing happens, but it still counts as doing one operation.
We want to do a total of N operations of these kinds in some order so that one of the pieces will be at coordinate A and the other at coordinate B. Find the number of ways to move the pieces to achieve it. The answer can be enormous, so compute the count modulo 998244353.
Two ways to move the pieces are considered different if and only if there exists an integer i (1 \leq i \leq N) such that the set of the coordinates occupied by the pieces after the i-th operation is different in those two ways.
Constraints
* 1 \leq N \leq 10^7
* 0 \leq A \leq B \leq N
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N A B
Output
Print the number of ways to move the pieces to achieve our objective, modulo 998244353.
Examples
Input
5 1 3
Output
4
Input
10 0 0
Output
1
Input
10 4 6
Output
197
Input
1000000 100000 200000
Output
758840509
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 2e7 + 10, mod = 998244353;
inline int gi()
{
char c = getchar();
while (c < '0' || c > '9') c = getchar();
int sum = 0;
while ('0' <= c && c <= '9') sum = sum * 10 + c - 48, c = getchar();
return sum;
}
inline int add(int x, int y) {return x + y > mod ? x + y - mod : x + y;}
inline int sub(int x, int y) {return x < y ? x - y + mod : x - y;}
inline int fpow(int x, int k)
{
int res = 1;
while (k) {
if (k & 1) res = (ll)res * x % mod;
k >>= 1; x = (ll)x * x % mod;
}
return res;
}
int n, a, b;
int fac[maxn], ifac[maxn];
inline int C(int m, int n)
{
if (n < 0 || m < n) return 0;
return (ll)fac[m] * ifac[n] % mod * ifac[m - n] % mod;
}
inline int F(int x, int y)
{
if (y <= x - 1) return 0;
return sub(C(x + y, x), C(x + y, x - 1));
}
int main()
{
n = gi(); a = gi(); b = gi();
fac[0] = ifac[0] = ifac[1] = 1;
for (int i = 1; i < maxn; ++i) fac[i] = (ll)fac[i - 1] * i % mod;
ifac[maxn - 1] = fpow(fac[maxn - 1], mod - 2);
for (int i = maxn - 2; ~i; --i) ifac[i] = (ll)ifac[i + 1] * (i + 1) % mod;
if (!b) return puts("1"), 0;
int ans = 0;
for (int i = 0; i <= n - b; ++i) {
int tmp = F(i, b - 1);
if (i + b == n) {
if (i == a) ans = add(ans, tmp);
} else {
int x = n - b - i - 1, y = a - i + 1;
ans = (ans + (ll)tmp * C(x + y - 1, y - 1)) % mod;
}
}
printf("%d\n", ans);
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
The Queen of England has n trees growing in a row in her garden. At that, the i-th (1 ≤ i ≤ n) tree from the left has height ai meters. Today the Queen decided to update the scenery of her garden. She wants the trees' heights to meet the condition: for all i (1 ≤ i < n), ai + 1 - ai = k, where k is the number the Queen chose.
Unfortunately, the royal gardener is not a machine and he cannot fulfill the desire of the Queen instantly! In one minute, the gardener can either decrease the height of a tree to any positive integer height or increase the height of a tree to any positive integer height. How should the royal gardener act to fulfill a whim of Her Majesty in the minimum number of minutes?
Input
The first line contains two space-separated integers: n, k (1 ≤ n, k ≤ 1000). The second line contains n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 1000) — the heights of the trees in the row.
Output
In the first line print a single integer p — the minimum number of minutes the gardener needs. In the next p lines print the description of his actions.
If the gardener needs to increase the height of the j-th (1 ≤ j ≤ n) tree from the left by x (x ≥ 1) meters, then print in the corresponding line "+ j x". If the gardener needs to decrease the height of the j-th (1 ≤ j ≤ n) tree from the left by x (x ≥ 1) meters, print on the corresponding line "- j x".
If there are multiple ways to make a row of trees beautiful in the minimum number of actions, you are allowed to print any of them.
Examples
Input
4 1
1 2 1 5
Output
2
+ 3 2
- 4 1
Input
4 1
1 2 3 4
Output
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, k, ar[1111], ans = 1 << 28, t;
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) scanf("%d", &ar[i]);
for (int i = 1; i <= n; i++) {
if (ar[i] - (i - 1) * k <= 0) continue;
int g = 0;
for (int j = 1; j <= n; j++) {
if (ar[j] != ar[i] + (j - i) * k) {
g++;
}
}
if (ans > g) t = i;
ans = min(g, ans);
}
cout << ans << endl;
for (int i = 1; i <= n; i++) {
if (ar[i] != ar[t] + (i - t) * k) {
if (ar[i] < ar[t] + (i - t) * k) {
printf("+ %d %d\n", i, ar[t] + (i - t) * k - ar[i]);
} else {
printf("- %d %d\n", i, ar[i] - ar[t] - (i - t) * k);
}
}
}
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
Snuke lives in another world, where slimes are real creatures and kept by some people. Slimes come in N colors. Those colors are conveniently numbered 1 through N. Snuke currently has no slime. His objective is to have slimes of all the colors together.
Snuke can perform the following two actions:
* Select a color i (1≤i≤N), such that he does not currently have a slime in color i, and catch a slime in color i. This action takes him a_i seconds.
* Cast a spell, which changes the color of all the slimes that he currently has. The color of a slime in color i (1≤i≤N-1) will become color i+1, and the color of a slime in color N will become color 1. This action takes him x seconds.
Find the minimum time that Snuke needs to have slimes in all N colors.
Constraints
* 2≤N≤2,000
* a_i are integers.
* 1≤a_i≤10^9
* x is an integer.
* 1≤x≤10^9
Input
The input is given from Standard Input in the following format:
N x
a_1 a_2 ... a_N
Output
Find the minimum time that Snuke needs to have slimes in all N colors.
Examples
Input
2 10
1 100
Output
12
Input
3 10
100 1 100
Output
23
Input
4 10
1 2 3 4
Output
10
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2040;
long long a[maxn], b[maxn], x;
int main(){
int n; cin >> n >> x;
for(int i = 0; i < n; i++) cin >> a[i];
long long ans = 0;
for(int i = 0; i < n; i++) ans += a[i];
for(int i = 0; i < n; i++) b[i] = a[i];
for(int i = 1; i < n; i++){
for(int j = 0; j < n; j++) b[j] = min(b[j], a[(j - i + n) % n]);
long long sum = 0;
for(int j = 0; j < n; j++) sum += b[j];
ans = min(ans, sum + i * x);
}
cout << ans << endl;
return 0;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
In Republic of AtCoder, Snuke Chameleons (Family: Chamaeleonidae, Genus: Bartaberia) are very popular pets. Ringo keeps N Snuke Chameleons in a cage.
A Snuke Chameleon that has not eaten anything is blue. It changes its color according to the following rules:
* A Snuke Chameleon that is blue will change its color to red when the number of red balls it has eaten becomes strictly larger than the number of blue balls it has eaten.
* A Snuke Chameleon that is red will change its color to blue when the number of blue balls it has eaten becomes strictly larger than the number of red balls it has eaten.
Initially, every Snuke Chameleon had not eaten anything. Ringo fed them by repeating the following process K times:
* Grab either a red ball or a blue ball.
* Throw that ball into the cage. Then, one of the chameleons eats it.
After Ringo threw in K balls, all the chameleons were red. We are interested in the possible ways Ringo could have thrown in K balls. How many such ways are there? Find the count modulo 998244353. Here, two ways to throw in balls are considered different when there exists i such that the color of the ball that are thrown in the i-th throw is different.
Constraints
* 1 \leq N,K \leq 5 \times 10^5
* N and K are integers.
Input
Input is given from Standard Input in the following format:
N K
Output
Print the possible ways Ringo could have thrown in K balls, modulo 998244353.
Examples
Input
2 4
Output
7
Input
3 7
Output
57
Input
8 3
Output
0
Input
8 10
Output
46
Input
123456 234567
Output
857617983
### Response
```cpp
#include<cstdio>
const int N=500007,P=998244353;
int fac[N],ifac[N];
void inc(int&a,int b){a+=b-P,a+=a>>31&P;}
int mod(int x){return x+(x>>31&P);}
int pow(int a,int b){int r=1;for(;b;b>>=1,a=1ll*a*a%P)if(b&1)r=1ll*a*r%P;return r;}
int C(int n,int m){return n<m||m<0? 0:1ll*fac[n]*ifac[m]%P*ifac[n-m]%P;}
int main()
{
int n,k,ans=0;scanf("%d%d",&n,&k);
for(int i=fac[0]=1;i<=k;++i) fac[i]=1ll*fac[i-1]*i%P;
ifac[k]=pow(fac[k],P-2);for(int i=k;i;--i) ifac[i-1]=1ll*ifac[i]*i%P;
for(int i=0,f;i+i<=k&&i+n<=k;++i) f=(i+i==k),inc(ans,mod(C(k-f,i-f)-C(k-f,i+i+n-k-1-f)));
printf("%d",ans);
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
Vasya has a non-negative integer n. He wants to round it to nearest integer, which ends up with 0. If n already ends up with 0, Vasya considers it already rounded.
For example, if n = 4722 answer is 4720. If n = 5 Vasya can round it to 0 or to 10. Both ways are correct.
For given n find out to which integer will Vasya round it.
Input
The first line contains single integer n (0 ≤ n ≤ 109) — number that Vasya has.
Output
Print result of rounding n. Pay attention that in some cases answer isn't unique. In that case print any correct answer.
Examples
Input
5
Output
0
Input
113
Output
110
Input
1000000000
Output
1000000000
Input
5432359
Output
5432360
Note
In the first example n = 5. Nearest integers, that ends up with zero are 0 and 10. Any of these answers is correct, so you can print 0 or 10.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
if (n % 10 == 0) {
} else if (n % 10 < 5)
n = (n / 10) * 10;
else
n = (n / 10) * 10 + 10;
cout << n << endl;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
You are given two strings s and t, both consisting only of lowercase Latin letters.
The substring s[l..r] is the string which is obtained by taking characters s_l, s_{l + 1}, ..., s_r without changing the order.
Each of the occurrences of string a in a string b is a position i (1 ≤ i ≤ |b| - |a| + 1) such that b[i..i + |a| - 1] = a (|a| is the length of string a).
You are asked q queries: for the i-th query you are required to calculate the number of occurrences of string t in a substring s[l_i..r_i].
Input
The first line contains three integer numbers n, m and q (1 ≤ n, m ≤ 10^3, 1 ≤ q ≤ 10^5) — the length of string s, the length of string t and the number of queries, respectively.
The second line is a string s (|s| = n), consisting only of lowercase Latin letters.
The third line is a string t (|t| = m), consisting only of lowercase Latin letters.
Each of the next q lines contains two integer numbers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the arguments for the i-th query.
Output
Print q lines — the i-th line should contain the answer to the i-th query, that is the number of occurrences of string t in a substring s[l_i..r_i].
Examples
Input
10 3 4
codeforces
for
1 3
3 10
5 6
5 7
Output
0
1
0
1
Input
15 2 3
abacabadabacaba
ba
1 15
3 4
2 14
Output
4
0
3
Input
3 5 2
aaa
baaab
1 3
1 1
Output
0
0
Note
In the first example the queries are substrings: "cod", "deforces", "fo" and "for", respectively.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 100005;
int BIT[MaxN];
void update(int pos) {
int i, j, p, q;
for (i = pos; i < MaxN; i += i & (-i)) {
BIT[i] += 1;
}
}
int query(int pos) {
int i, j, p = 0, q;
for (i = pos; i > 0; i -= i & (-i)) {
p += BIT[i];
}
return p;
}
int main() {
cin.tie(0), ios_base::sync_with_stdio(0);
int N, M, K, i, j, p, q;
bool proof;
cin >> N >> M >> K;
string a, b;
cin >> a >> b;
for (i = 0; i <= N - M; i++) {
proof = 1;
for (j = i; j < i + M; j++) {
if (a[j] != b[j - i]) {
proof = 0;
continue;
}
}
if (proof) {
update(i + 1);
}
}
for (i = 0; i < K; i++) {
cin >> p >> q;
if (q - M - p + 1 < 0)
cout << "0\n";
else
cout << query(q - M + 1) - query(p - 1) << "\n";
}
}
``` |
### Prompt
Create a solution in CPP for the following problem:
After a probationary period in the game development company of IT City Petya was included in a group of the programmers that develops a new turn-based strategy game resembling the well known "Heroes of Might & Magic". A part of the game is turn-based fights of big squadrons of enemies on infinite fields where every cell is in form of a hexagon.
Some of magic effects are able to affect several field cells at once, cells that are situated not farther than n cells away from the cell in which the effect was applied. The distance between cells is the minimum number of cell border crosses on a path from one cell to another.
It is easy to see that the number of cells affected by a magic effect grows rapidly when n increases, so it can adversely affect the game performance. That's why Petya decided to write a program that can, given n, determine the number of cells that should be repainted after effect application, so that game designers can balance scale of the effects and the game performance. Help him to do it. Find the number of hexagons situated not farther than n cells away from a given cell.
<image>
Input
The only line of the input contains one integer n (0 ≤ n ≤ 109).
Output
Output one integer — the number of hexagons situated not farther than n cells away from a given cell.
Examples
Input
2
Output
19
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
cout << 1 + n * ((n + 1) * 6) / 2;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
The administration of the Tomsk Region firmly believes that it's time to become a megacity (that is, get population of one million). Instead of improving the demographic situation, they decided to achieve its goal by expanding the boundaries of the city.
The city of Tomsk can be represented as point on the plane with coordinates (0; 0). The city is surrounded with n other locations, the i-th one has coordinates (xi, yi) with the population of ki people. You can widen the city boundaries to a circle of radius r. In such case all locations inside the circle and on its border are included into the city.
Your goal is to write a program that will determine the minimum radius r, to which is necessary to expand the boundaries of Tomsk, so that it becomes a megacity.
Input
The first line of the input contains two integers n and s (1 ≤ n ≤ 103; 1 ≤ s < 106) — the number of locatons around Tomsk city and the population of the city. Then n lines follow. The i-th line contains three integers — the xi and yi coordinate values of the i-th location and the number ki of people in it (1 ≤ ki < 106). Each coordinate is an integer and doesn't exceed 104 in its absolute value.
It is guaranteed that no two locations are at the same point and no location is at point (0; 0).
Output
In the output, print "-1" (without the quotes), if Tomsk won't be able to become a megacity. Otherwise, in the first line print a single real number — the minimum radius of the circle that the city needs to expand to in order to become a megacity.
The answer is considered correct if the absolute or relative error don't exceed 10 - 6.
Examples
Input
4 999998
1 1 1
2 2 1
3 3 1
2 -2 1
Output
2.8284271
Input
4 999998
1 1 2
2 2 1
3 3 1
2 -2 1
Output
1.4142136
Input
2 1
1 1 999997
2 2 1
Output
-1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000000;
pair<double, int> arr[MAXN];
int main() {
ios_base::sync_with_stdio(0);
int n, s;
cin >> n >> s;
for (int i = 0; i < n; i++) {
double x, y;
int k;
cin >> x >> y >> k;
double d = sqrt((x * x) + (y * y));
arr[i] = pair<double, int>(d, k);
}
sort(arr, arr + n);
double r = 0;
for (int i = 0; i < n; i++) {
s += arr[i].second;
r = arr[i].first;
if (s >= 1000000) break;
}
if (s >= 1000000)
printf("%.7lf\n", r);
else
cout << "-1\n";
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
There are a total of n x n squares, n rows vertically and n columns horizontally. Some squares are marked. Create a program that reads the marked state of each square and displays the length of the side of the largest square consisting of only the unmarked squares as an output.
For example, each dataset is given the following data:
Ten
... * .... **
..........
** .... ** ..
........ *.
.. * .......
..........
. * ........
..........
.... * .. ***
. * .... * ...
One line of input data represents the square of one line. Of the character strings in the input data,. (Period) indicates unmarked squares, and * (asterisk) indicates marked squares.
In the above example, the square indicated by 0 in the figure below is the largest.
... * .... **
..........
** .... ** ..
... 00000 *.
.. * 00000 ..
... 00000 ..
. * .00000 ..
... 00000 ..
.... * .. ***
. * .... * ...
Therefore, if you output 5, the answer will be correct.
If all the squares are marked, output 0.
Input
Multiple datasets are given in the above format. When n is 0, it is the last input. n is 1000 or less. The input data string does not contain any characters other than periods, asterisks, and line breaks. The number of datasets does not exceed 50.
Output
For each dataset, output the length (integer) of the side of the largest square on one line.
Example
Input
10
...*....**
..........
**....**..
........*.
..*.......
..........
.*........
..........
....*..***
.*....*...
10
****.*****
*..*.*....
****.*....
*....*....
*....*****
..........
****.*****
*..*...*..
****...*..
*..*...*..
0
Output
5
3
### Response
```cpp
#include <iostream>
#include <cstring>
using namespace std;
int main () {
int n;
while (cin >> n, n) {
char field[n + 1][n + 1];
int dp[n + 1][n + 1];
memset(dp, 0, sizeof(dp));
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
cin >> field[i][j];
}
}
for (int i = 0; i <= n; i++) {
dp[i][0] = dp[0][i] = 0;
}
int result = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (field[i][j] == '.') {
dp[i][j] = min(dp[i - 1][j - 1], min(dp[i - 1][j], dp[i][j - 1])) + 1;
result = max(dp[i][j], result);
}
// cout << '\t' << dp[i][j];
}
// cout << endl;
}
cout << result << endl;
}
return 0;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
This is the easy version of this problem. The only difference is the limit of n - the length of the input string. In this version, 1 ≤ n ≤ 2000. The hard version of this challenge is not offered in the round for the second division.
Let's define a correct bracket sequence and its depth as follow:
* An empty string is a correct bracket sequence with depth 0.
* If "s" is a correct bracket sequence with depth d then "(s)" is a correct bracket sequence with depth d + 1.
* If "s" and "t" are both correct bracket sequences then their concatenation "st" is a correct bracket sequence with depth equal to the maximum depth of s and t.
For a (not necessarily correct) bracket sequence s, we define its depth as the maximum depth of any correct bracket sequence induced by removing some characters from s (possibly zero). For example: the bracket sequence s = "())(())" has depth 2, because by removing the third character we obtain a correct bracket sequence "()(())" with depth 2.
Given a string a consists of only characters '(', ')' and '?'. Consider all (not necessarily correct) bracket sequences obtained by replacing all characters '?' in a by either '(' or ')'. Calculate the sum of all the depths of all these bracket sequences. As this number can be large, find it modulo 998244353.
Hacks in this problem in the first division can be done only if easy and hard versions of this problem was solved.
Input
The only line contains a non-empty string consist of only '(', ')' and '?'. The length of the string is at most 2000.
Output
Print the answer modulo 998244353 in a single line.
Examples
Input
??
Output
1
Input
(?(?))
Output
9
Note
In the first test case, we can obtain 4 bracket sequences by replacing all characters '?' with either '(' or ')':
* "((". Its depth is 0;
* "))". Its depth is 0;
* ")(". Its depth is 0;
* "()". Its depth is 1.
So, the answer is 1 = 0 + 0 + 0 + 1.
In the second test case, we can obtain 4 bracket sequences by replacing all characters '?' with either '(' or ')':
* "(((())". Its depth is 2;
* "()()))". Its depth is 2;
* "((()))". Its depth is 3;
* "()(())". Its depth is 2.
So, the answer is 9 = 2 + 2 + 3 + 2.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 2002;
const long long MOD = 998244353;
char s[N];
int n;
int pre[N][3];
long long c[N][N];
int main() {
for (int i = 0; i < N; i++) c[i][0] = 1;
for (int i = 1; i < N; i++) {
for (int j = 1; j <= i; j++) {
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % MOD;
}
}
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; i++) {
pre[i][0] = pre[i - 1][0] + (s[i] == '(' ? 1 : 0);
pre[i][1] = pre[i - 1][1] + (s[i] == ')' ? 1 : 0);
pre[i][2] = pre[i - 1][2] + (s[i] == '?' ? 1 : 0);
}
long long ans = 0;
for (int i = 1; i < n; i++) {
int c1 = pre[i][0], c2 = pre[n][1] - pre[i][1];
int x1 = pre[i][2], x2 = pre[n][2] - pre[i][2];
for (int j = 0; j <= x1; j++) {
int R = c1 + j - c2;
if (R >= 0 && R <= x2) {
ans = ans + c[x1][j] * c[x2][R] % MOD * (c1 + j) % MOD;
ans = (ans % MOD + MOD) % MOD;
}
}
}
cout << ans << endl;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
Shichi-Go-San (literally "Seven-Five-Three") is a traditional event in a certain country to celebrate the growth of seven-, five- and three-year-old children.
Takahashi is now X years old. Will his growth be celebrated in Shichi-Go-San this time?
Constraints
* 1 ≤ X ≤ 9
* X is an integer.
Input
Input is given from Standard Input in the following format:
X
Output
If Takahashi's growth will be celebrated, print `YES`; if it will not, print `NO`.
Examples
Input
5
Output
YES
Input
6
Output
NO
### Response
```cpp
#include<iostream>
using namespace std;
int main() {
int X;
cin >> X;
cout << (((X | X << 1) & 7) == 7 ? "YES" : "NO");
return 0;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
There are N participants in the CODE FESTIVAL 2016 Qualification contests. The participants are either students in Japan, students from overseas, or neither of these.
Only Japanese students or overseas students can pass the Qualification contests. The students pass when they satisfy the conditions listed below, from the top rank down. Participants who are not students cannot pass the Qualification contests.
* A Japanese student passes the Qualification contests if the number of the participants who have already definitively passed is currently fewer than A+B.
* An overseas student passes the Qualification contests if the number of the participants who have already definitively passed is currently fewer than A+B and the student ranks B-th or above among all overseas students.
A string S is assigned indicating attributes of all participants. If the i-th character of string S is `a`, this means the participant ranked i-th in the Qualification contests is a Japanese student; `b` means the participant ranked i-th is an overseas student; and `c` means the participant ranked i-th is neither of these.
Write a program that outputs for all the participants in descending rank either `Yes` if they passed the Qualification contests or `No` if they did not pass.
Constraints
* 1≦N,A,B≦100000
* A+B≦N
* S is N characters long.
* S consists only of the letters `a`, `b` and `c`.
Input
Inputs are provided from Standard Input in the following form.
N A B
S
Output
Output N lines. On the i-th line, output `Yes` if the i-th participant passed the Qualification contests or `No` if that participant did not pass.
Examples
Input
10 2 3
abccabaabb
Output
Yes
Yes
No
No
Yes
Yes
Yes
No
No
No
Input
12 5 2
cabbabaacaba
Output
No
Yes
Yes
Yes
Yes
No
Yes
Yes
No
Yes
No
No
Input
5 2 2
ccccc
Output
No
No
No
No
No
### Response
```cpp
#include <cstdio>
#include <string>
#include <iostream>
using namespace std;
int n,a,b;
int main(void){
scanf("%d%d%d",&n,&a,&b);
string str;
cin >> str;
for(int i=0;i<n;i++){
if(str[i]=='a'){
if(a+b>0){
printf("Yes\n");
if(a>0)a--;
else b--;
}else printf("No\n");
}
if(str[i]=='b'){
if(b>0){
printf("Yes\n");
b--;
}else printf("No\n");
}
if(str[i]=='c')printf("No\n");
}
return 0;
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
Areas on the Cross-Section Diagram
Your task is to simulate a flood damage.
For a given cross-section diagram, reports areas of flooded sections.
<image>
Assume that rain is falling endlessly in the region and the water overflowing from the region is falling in the sea at the both sides. For example, for the above cross-section diagram, the rain will create floods which have areas of 4, 2, 1, 19 and 9 respectively.
output
Report the areas of floods in the following format:
$A$
$k$ $L_1$ $L_2$ ... $L_k$
In the first line, print the total area $A$ of created floods.
In the second line, print the number of floods $k$ and areas $L_i (i = 1, 2, ..., k)$ for each flood from the left side of the cross-section diagram. Print a space character before $L_i$.
Constraints
* $1 \leq$ length of the string $\leq 20,000$
Input
A string, which represents slopes and flatlands by '/', '\' and '_' respectively, is given in a line. For example, the region of the above example is given by a string "\\\///\\_/\/\\\\\\\/_/\\\///__\\\\\\_\\\/_\/_/\".
Examples
Input
\\//
Output
4
1 4
Input
\\///\_/\/\\\\/_/\\///__\\\_\\/_\/_/\
Output
35
5 4 2 1 19 9
### Response
```cpp
#include<iostream>
#include<stack>
#include<map>
#include<vector>
using namespace std;
stack<int>a;
stack<pair<int,int> >a1;
int sum;//统计总共有多少洪水
int part;
int main()
{
int i = 0;
char c;
while (cin >> c) {
if (c == '\\'){
a.push(i);
}
else if (c == '/'&&!a.empty()) {
sum+= i - a.top();
part = i - a.top();
while (!a1.empty() && a1.top().first > a.top()) {
part += a1.top().second;
a1.pop();
}
a1.push(make_pair(a.top(), part));
a.pop();
}
i++;
}
vector<int>ans;
while (!a1.empty()) {
ans.push_back(a1.top().second);
a1.pop();
}
cout << sum << endl;
cout << ans.size();
for (int i = ans.size() - 1; i >= 0; i--) {
cout << " " << ans[i];
}
cout << endl;
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
You are given an array a consisting of n integers.
Your task is to determine if a has some subsequence of length at least 3 that is a palindrome.
Recall that an array b is called a subsequence of the array a if b can be obtained by removing some (possibly, zero) elements from a (not necessarily consecutive) without changing the order of remaining elements. For example, [2], [1, 2, 1, 3] and [2, 3] are subsequences of [1, 2, 1, 3], but [1, 1, 2] and [4] are not.
Also, recall that a palindrome is an array that reads the same backward as forward. In other words, the array a of length n is the palindrome if a_i = a_{n - i - 1} for all i from 1 to n. For example, arrays [1234], [1, 2, 1], [1, 3, 2, 2, 3, 1] and [10, 100, 10] are palindromes, but arrays [1, 2] and [1, 2, 3, 1] are not.
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.
Next 2t lines describe test cases. The first line of the test case contains one integer n (3 ≤ n ≤ 5000) — the length of a. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n), where a_i is the i-th element of a.
It is guaranteed that the sum of n over all test cases does not exceed 5000 (∑ n ≤ 5000).
Output
For each test case, print the answer — "YES" (without quotes) if a has some subsequence of length at least 3 that is a palindrome and "NO" otherwise.
Example
Input
5
3
1 2 1
5
1 2 2 3 2
3
1 1 2
4
1 2 2 1
10
1 1 2 2 3 3 4 4 5 5
Output
YES
YES
NO
YES
NO
Note
In the first test case of the example, the array a has a subsequence [1, 2, 1] which is a palindrome.
In the second test case of the example, the array a has two subsequences of length 3 which are palindromes: [2, 3, 2] and [2, 2, 2].
In the third test case of the example, the array a has no subsequences of length at least 3 which are palindromes.
In the fourth test case of the example, the array a has one subsequence of length 4 which is a palindrome: [1, 2, 2, 1] (and has two subsequences of length 3 which are palindromes: both are [1, 2, 1]).
In the fifth test case of the example, the array a has no subsequences of length at least 3 which are palindromes.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int a[200005];
int main() {
int t, cnt, sum, x, n;
cin >> t;
while (t--) {
int flag = 0;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n - 1; i++) {
for (int j = i + 1; j < n; j++) {
if (a[j] == a[i] && (j - i) > 1) {
flag = 1;
}
}
if (flag == 1) break;
}
if (flag == 0)
cout << "NO" << endl;
else
cout << "YES" << endl;
}
return 0;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
Young Teodor enjoys drawing. His favourite hobby is drawing segments with integer borders inside his huge [1;m] segment. One day Teodor noticed that picture he just drawn has one interesting feature: there doesn't exist an integer point, that belongs each of segments in the picture. Having discovered this fact, Teodor decided to share it with Sasha.
Sasha knows that Teodor likes to show off so he never trusts him. Teodor wants to prove that he can be trusted sometimes, so he decided to convince Sasha that there is no such integer point in his picture, which belongs to each segment. However Teodor is lazy person and neither wills to tell Sasha all coordinates of segments' ends nor wills to tell him their amount, so he suggested Sasha to ask him series of questions 'Given the integer point xi, how many segments in Fedya's picture contain that point?', promising to tell correct answers for this questions.
Both boys are very busy studying and don't have much time, so they ask you to find out how many questions can Sasha ask Teodor, that having only answers on his questions, Sasha can't be sure that Teodor isn't lying to him. Note that Sasha doesn't know amount of segments in Teodor's picture. Sure, Sasha is smart person and never asks about same point twice.
Input
First line of input contains two integer numbers: n and m (1 ≤ n, m ≤ 100 000) — amount of segments of Teodor's picture and maximal coordinate of point that Sasha can ask about.
ith of next n lines contains two integer numbers li and ri (1 ≤ li ≤ ri ≤ m) — left and right ends of ith segment in the picture. Note that that left and right ends of segment can be the same point.
It is guaranteed that there is no integer point, that belongs to all segments.
Output
Single line of output should contain one integer number k – size of largest set (xi, cnt(xi)) where all xi are different, 1 ≤ xi ≤ m, and cnt(xi) is amount of segments, containing point with coordinate xi, such that one can't be sure that there doesn't exist point, belonging to all of segments in initial picture, if he knows only this set(and doesn't know n).
Examples
Input
2 4
1 2
3 4
Output
4
Input
4 6
1 3
2 3
4 6
5 6
Output
5
Note
First example shows situation where Sasha can never be sure that Teodor isn't lying to him, because even if one knows cnt(xi) for each point in segment [1;4], he can't distinguish this case from situation Teodor has drawn whole [1;4] segment.
In second example Sasha can ask about 5 points e.g. 1, 2, 3, 5, 6, still not being sure if Teodor haven't lied to him. But once he knows information about all points in [1;6] segment, Sasha can be sure that Teodor haven't lied to him.
### Response
```cpp
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("no-stack-protector")
#pragma GCC target("sse,sse2,ssse3,sse3,sse4,popcnt,avx,mmx,abm,tune=native")
using namespace std;
vector<long long> lnis(vector<long long> a) {
long long n = a.size();
vector<long long> p(n);
iota(p.rbegin(), p.rend(), 0);
stable_sort(p.begin(), p.end(),
[&](long long i, long long j) { return a[i] < a[j]; });
vector<long long> t(n + 1);
auto upd = [&](long long i, long long x) {
i++;
t[i] = x;
while (i) t[i] = max(t[i], x), i -= i & -i;
};
auto qry = [&](long long i) {
i++;
long long ret = 0;
while (i < (long long)t.size()) ret = max(ret, t[i]), i += i & -i;
return ret;
};
vector<long long> ret(n);
for (long long i = 0; i < n; i++) {
long long idx = p[i];
long long x = qry(idx) + 1;
upd(idx, x);
ret[idx] = x;
}
return ret;
}
signed main() {
cin.tie(nullptr)->sync_with_stdio(false);
long long n, m;
cin >> n >> m;
vector<long long> ct(m);
for (long long i = 0; i < n; i++) {
long long l, r;
cin >> l >> r;
l--;
r--;
ct[l]++;
if (r + 1 < m) ct[r + 1]--;
}
partial_sum(ct.begin(), ct.end(), ct.begin());
auto fwd = lnis(ct);
reverse(ct.begin(), ct.end());
auto rev = lnis(ct);
reverse(rev.begin(), rev.end());
long long ans = 0;
for (long long i = 0; i < m; i++) {
ans = max(ans, fwd[i] + rev[i] - 1);
}
cout << ans << "\n";
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
Petr wants to make a calendar for current month. For this purpose he draws a table in which columns correspond to weeks (a week is seven consequent days from Monday to Sunday), rows correspond to weekdays, and cells contain dates. For example, a calendar for January 2017 should look like on the picture:
<image>
Petr wants to know how many columns his table should have given the month and the weekday of the first date of that month? Assume that the year is non-leap.
Input
The only line contain two integers m and d (1 ≤ m ≤ 12, 1 ≤ d ≤ 7) — the number of month (January is the first month, December is the twelfth) and the weekday of the first date of this month (1 is Monday, 7 is Sunday).
Output
Print single integer: the number of columns the table should have.
Examples
Input
1 7
Output
6
Input
1 1
Output
5
Input
11 6
Output
5
Note
The first example corresponds to the January 2017 shown on the picture in the statements.
In the second example 1-st January is Monday, so the whole month fits into 5 columns.
In the third example 1-st November is Saturday and 5 columns is enough.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int CASE = 1;
int TEST;
int mon[13] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int main(void) {
int a = 0, b = 0, i = 0, n = 0, m = 0, d = 0;
scanf("%d %d", &m, &d);
if (m == 2) {
if (d == 1) {
printf("4\n");
} else {
printf("5\n");
}
} else if (m == 4 || m == 6 || m == 9 || m == 11) {
if (d == 7) {
printf("6\n");
} else {
printf("5\n");
}
} else {
if (d == 7 || d == 6) {
printf("6\n");
} else {
printf("5\n");
}
}
return 0;
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
You are given a sequence of n pairs of integers: (a_1, b_1), (a_2, b_2), ... , (a_n, b_n). This sequence is called bad if it is sorted in non-descending order by first elements or if it is sorted in non-descending order by second elements. Otherwise the sequence is good. There are examples of good and bad sequences:
* s = [(1, 2), (3, 2), (3, 1)] is bad because the sequence of first elements is sorted: [1, 3, 3];
* s = [(1, 2), (3, 2), (1, 2)] is bad because the sequence of second elements is sorted: [2, 2, 2];
* s = [(1, 1), (2, 2), (3, 3)] is bad because both sequences (the sequence of first elements and the sequence of second elements) are sorted;
* s = [(1, 3), (3, 3), (2, 2)] is good because neither the sequence of first elements ([1, 3, 2]) nor the sequence of second elements ([3, 3, 2]) is sorted.
Calculate the number of permutations of size n such that after applying this permutation to the sequence s it turns into a good sequence.
A permutation p of size n is a sequence p_1, p_2, ... , p_n consisting of n distinct integers from 1 to n (1 ≤ p_i ≤ n). If you apply permutation p_1, p_2, ... , p_n to the sequence s_1, s_2, ... , s_n you get the sequence s_{p_1}, s_{p_2}, ... , s_{p_n}. For example, if s = [(1, 2), (1, 3), (2, 3)] and p = [2, 3, 1] then s turns into [(1, 3), (2, 3), (1, 2)].
Input
The first line contains one integer n (1 ≤ n ≤ 3 ⋅ 10^5).
The next n lines contains description of sequence s. The i-th line contains two integers a_i and b_i (1 ≤ a_i, b_i ≤ n) — the first and second elements of i-th pair in the sequence.
The sequence s may contain equal elements.
Output
Print the number of permutations of size n such that after applying this permutation to the sequence s it turns into a good sequence. Print the answer modulo 998244353 (a prime number).
Examples
Input
3
1 1
2 2
3 1
Output
3
Input
4
2 3
2 2
2 1
2 4
Output
0
Input
3
1 1
1 1
2 3
Output
4
Note
In first test case there are six permutations of size 3:
1. if p = [1, 2, 3], then s = [(1, 1), (2, 2), (3, 1)] — bad sequence (sorted by first elements);
2. if p = [1, 3, 2], then s = [(1, 1), (3, 1), (2, 2)] — bad sequence (sorted by second elements);
3. if p = [2, 1, 3], then s = [(2, 2), (1, 1), (3, 1)] — good sequence;
4. if p = [2, 3, 1], then s = [(2, 2), (3, 1), (1, 1)] — good sequence;
5. if p = [3, 1, 2], then s = [(3, 1), (1, 1), (2, 2)] — bad sequence (sorted by second elements);
6. if p = [3, 2, 1], then s = [(3, 1), (2, 2), (1, 1)] — good sequence.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
#pragma GCC push_options
#pragma GCC optimize("unroll-loops")
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
pair<long long, long long> ar[n];
unordered_map<long long, long long> ump1, ump2;
for (int i = 0; i < n; i++) {
cin >> ar[i].first >> ar[i].second;
ump1[ar[i].first]++;
ump2[ar[i].second]++;
}
long long fact[n + 1];
fact[0] = 1ll;
for (int i = 1; i <= n; i++) fact[i] = (fact[i - 1] * i) % 998244353;
long long ans = fact[n];
long long ans1 = 1ll;
for (auto it = ump1.begin(); it != ump1.end(); it++)
ans1 = (ans1 * (fact[it->second])) % 998244353;
long long ans2 = 1ll;
for (auto it = ump2.begin(); it != ump2.end(); it++)
ans2 = (ans2 * (fact[it->second])) % 998244353;
sort(ar, ar + n);
bool flag = true;
for (int i = 1; i < n; i++) {
if (ar[i].second >= ar[i - 1].second)
;
else {
flag = false;
break;
}
}
long long ans3;
if (flag) {
ans3 = 1ll;
map<pair<long long, long long>, long long> m;
for (int i = 0; i < n; i++) {
m[make_pair(ar[i].first, ar[i].second)]++;
}
for (auto it = m.begin(); it != m.end(); it++)
ans3 = (ans3 * (fact[it->second])) % 998244353;
} else
ans3 = 0ll;
ans = (ans - ans1 + 998244353) % 998244353;
ans = (ans - ans2 + 998244353) % 998244353;
ans = (ans + ans3) % 998244353;
cout << ans << "\n";
return 0;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
Once upon a time in the thicket of the mushroom forest lived mushroom gnomes. They were famous among their neighbors for their magic mushrooms. Their magic nature made it possible that between every two neighboring mushrooms every minute grew another mushroom with the weight equal to the sum of weights of two neighboring ones.
The mushroom gnomes loved it when everything was in order, that's why they always planted the mushrooms in one line in the order of their weights' increasing. Well... The gnomes planted the mushrooms and went to eat. After x minutes they returned and saw that new mushrooms had grown up, so that the increasing order had been violated. The gnomes replanted all the mushrooms in the correct order, that is, they sorted the mushrooms in the order of the weights' increasing. And went to eat again (those gnomes were quite big eaters). What total weights modulo p will the mushrooms have in another y minutes?
Input
The first line contains four integers n, x, y, p (1 ≤ n ≤ 106, 0 ≤ x, y ≤ 1018, x + y > 0, 2 ≤ p ≤ 109) which represent the number of mushrooms, the number of minutes after the first replanting, the number of minutes after the second replanting and the module. The next line contains n integers ai which represent the mushrooms' weight in the non-decreasing order (0 ≤ ai ≤ 109).
Please, do not use %lld specificator to read or write 64-bit integers in C++. It is preffered to use cin (also you may use %I64d).
Output
The answer should contain a single number which is the total weights of the mushrooms modulo p in the end after x + y minutes.
Examples
Input
2 1 0 657276545
1 2
Output
6
Input
2 1 1 888450282
1 2
Output
14
Input
4 5 0 10000
1 2 3 4
Output
1825
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <class T>
void debug(T a, T b) {
for (; a != b; a++) cerr << *a << ' ';
cerr << endl;
}
template <class T>
bool isprime(T x) {
long long till = (T)sqrt(x + .0);
if (x <= 1) return 0;
if (x == 2) return 1;
if (x / 2 * 2 == x) return 0;
for (long long i = 3; i <= till; i += 2)
if (x / i * i == x) return 0;
return 1;
}
int n, p;
long long x, y;
int a[1000000];
inline long long mod(long long foo) {
foo += p;
return foo - foo / p * p;
}
struct Matrix {
int row, col;
vector<vector<long long> > body;
Matrix(int row, int col) {
this->row = row;
this->col = col;
body = vector<vector<long long> >(row, vector<long long>(col, 0));
}
Matrix(vector<vector<long long> > matrix) {
row = (long long)(matrix).size();
col = (long long)(matrix[0]).size();
body = matrix;
}
Matrix operator*(Matrix other) const {
Matrix ret = Matrix(row, other.col);
assert(col == other.row);
for (int i = 0; i < row; i++)
for (int j = 0; j < other.col; j++)
for (int k = 0; k < col; k++) {
ret.body[i][j] += mod(1LL * body[i][k] * other.body[k][j]);
ret.body[i][j] = mod(ret.body[i][j]);
}
return ret;
}
};
Matrix binpow(Matrix a, long long n) {
assert(n >= 1);
Matrix ret = a;
n--;
while (n > 0) {
if (n & 1) {
ret = ret * a;
n--;
}
a = a * a;
n >>= 1;
}
return ret;
}
int alacazam(int s, int f, int l, long long x) {
if (x == 0) return s;
return (Matrix(vector<vector<long long> >{{s, f, l}}) *
binpow(Matrix(vector<vector<long long> >{
{3, 0, 0}, {-1, 1, 0}, {-1, 0, 1}}),
x))
.body[0][0];
}
int fibazam(int f1, int f2, long long x) {
if (x == 0) return f2;
return (Matrix(vector<vector<long long> >{{f1, f2}}) *
binpow(Matrix(vector<vector<long long> >{{0, 1}, {1, 1}}), x))
.body[0][1];
}
int main() {
scanf(
"%d "
"%l"
"ld"
" "
"%l"
"ld"
" %d",
&n, &x, &y, &p);
int sum = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
a[i] = mod(a[i]);
sum = mod(sum + a[i]);
}
if (n == 1) {
printf("%d", sum);
return 0;
}
sum = alacazam(sum, a[0], a[n - 1], x);
a[n - 1] = fibazam(a[n - 2], a[n - 1], x);
sum = alacazam(sum, a[0], a[n - 1], y);
printf("%d", sum);
return EXIT_SUCCESS;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
A PIN code is a string that consists of exactly 4 digits. Examples of possible PIN codes: 7013, 0000 and 0990. Please note that the PIN code can begin with any digit, even with 0.
Polycarp has n (2 ≤ n ≤ 10) bank cards, the PIN code of the i-th card is p_i.
Polycarp has recently read a recommendation that it is better to set different PIN codes on different cards. Thus he wants to change the minimal number of digits in the PIN codes of his cards so that all n codes would become different.
Formally, in one step, Polycarp picks i-th card (1 ≤ i ≤ n), then in its PIN code p_i selects one position (from 1 to 4), and changes the digit in this position to any other. He needs to change the minimum number of digits so that all PIN codes become different.
Polycarp quickly solved this problem. Can you solve it?
Input
The first line contains integer t (1 ≤ t ≤ 100) — the number of test cases in the input. Then test cases follow.
The first line of each of t test sets contains a single integer n (2 ≤ n ≤ 10) — the number of Polycarp's bank cards. The next n lines contain the PIN codes p_1, p_2, ..., p_n — one per line. The length of each of them is 4. All PIN codes consist of digits only.
Output
Print the answers to t test sets. The answer to each set should consist of a n + 1 lines
In the first line print k — the least number of changes to make all PIN codes different. In the next n lines output the changed PIN codes in the order corresponding to their appearance in the input. If there are several optimal answers, print any of them.
Example
Input
3
2
1234
0600
2
1337
1337
4
3139
3139
3139
3139
Output
0
1234
0600
1
1337
1237
3
3139
3138
3939
6139
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int i, j, k, t, T, n, r, g, b, ans, x, y, z;
scanf("%lld", &(T));
for (__typeof(t) t = 1; t <= T; t++) {
ans = 0;
map<string, int> m;
scanf("%lld", &(n));
string s[n];
for (i = 0; i < n; i++) {
cin >> s[i];
m[s[i]]++;
}
for (i = n - 1; i >= 0; i--) {
if (m[s[i]] > 1) {
bool fg = 1;
for (j = 0; j < 4 && fg; j++) {
for (char ch = '0'; ch <= '9'; ch++) {
string temp = s[i];
temp[j] = ch;
if (m[temp] == 0) {
fg = 0;
ans++;
m[temp]++;
m[s[i]]--;
s[i] = temp;
break;
}
}
}
}
}
cout << ans << endl;
for (i = 0; i < n; i++) cout << s[i] << endl;
}
return 0;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
Mikhail the Freelancer dreams of two things: to become a cool programmer and to buy a flat in Moscow. To become a cool programmer, he needs at least p experience points, and a desired flat in Moscow costs q dollars. Mikhail is determined to follow his dreams and registered at a freelance site.
He has suggestions to work on n distinct projects. Mikhail has already evaluated that the participation in the i-th project will increase his experience by ai per day and bring bi dollars per day. As freelance work implies flexible working hours, Mikhail is free to stop working on one project at any time and start working on another project. Doing so, he receives the respective share of experience and money. Mikhail is only trying to become a cool programmer, so he is able to work only on one project at any moment of time.
Find the real value, equal to the minimum number of days Mikhail needs to make his dream come true.
For example, suppose Mikhail is suggested to work on three projects and a1 = 6, b1 = 2, a2 = 1, b2 = 3, a3 = 2, b3 = 6. Also, p = 20 and q = 20. In order to achieve his aims Mikhail has to work for 2.5 days on both first and third projects. Indeed, a1·2.5 + a2·0 + a3·2.5 = 6·2.5 + 1·0 + 2·2.5 = 20 and b1·2.5 + b2·0 + b3·2.5 = 2·2.5 + 3·0 + 6·2.5 = 20.
Input
The first line of the input contains three integers n, p and q (1 ≤ n ≤ 100 000, 1 ≤ p, q ≤ 1 000 000) — the number of projects and the required number of experience and money.
Each of the next n lines contains two integers ai and bi (1 ≤ ai, bi ≤ 1 000 000) — the daily increase in experience and daily income for working on the i-th project.
Output
Print a real value — the minimum number of days Mikhail needs to get the required amount of experience and money. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct, if <image>.
Examples
Input
3 20 20
6 2
1 3
2 6
Output
5.000000000000000
Input
4 1 1
2 3
3 2
2 3
3 2
Output
0.400000000000000
Note
First sample corresponds to the example in the problem statement.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using namespace std;
const double EPS = 1e-16;
struct PT {
double x, y;
PT() {}
PT(double x, double y) : x(x), y(y) {}
PT(const PT &p) : x(p.x), y(p.y) {}
PT operator+(const PT &p) const { return PT(x + p.x, y + p.y); }
PT operator-(const PT &p) const { return PT(x - p.x, y - p.y); }
PT operator*(double c) const { return PT(x * c, y * c); }
PT operator/(double c) const { return PT(x / c, y / c); }
bool operator<(const PT &rhs) const {
return make_pair(y, x) < make_pair(rhs.y, rhs.x);
}
bool operator==(const PT &rhs) const {
return make_pair(y, x) == make_pair(rhs.y, rhs.x);
}
};
double dot(PT p, PT q) { return p.x * q.x + p.y * q.y; }
double dist2(PT p, PT q) { return dot(p - q, p - q); }
double cross(PT p, PT q) { return p.x * q.y - p.y * q.x; }
double area2(PT a, PT b, PT c) {
return cross(a, b) + cross(b, c) + cross(c, a);
}
bool between(const PT &a, const PT &b, const PT &c) {
return (fabs(area2(a, b, c)) < EPS && (a.x - b.x) * (c.x - b.x) <= 0 &&
(a.y - b.y) * (c.y - b.y) <= 0);
}
void ConvexHull(vector<PT> &pts) {
sort(pts.begin(), pts.end());
pts.erase(unique(pts.begin(), pts.end()), pts.end());
vector<PT> up, dn;
for (int i = 0; i < pts.size(); i++) {
while (up.size() > 1 && area2(up[up.size() - 2], up.back(), pts[i]) >= 0)
up.pop_back();
while (dn.size() > 1 && area2(dn[dn.size() - 2], dn.back(), pts[i]) <= 0)
dn.pop_back();
up.push_back(pts[i]);
dn.push_back(pts[i]);
}
pts = dn;
for (int i = (int)up.size() - 2; i >= 1; i--) pts.push_back(up[i]);
}
PT ProjectPointSegment(PT a, PT b, PT c) {
double r = dot(b - a, b - a);
if (fabs(r) < EPS) return a;
r = dot(c - a, b - a) / r;
if (r < 0) return a;
if (r > 1) return b;
return a + (b - a) * r;
}
bool PointInPolygon(const vector<PT> &p, PT q) {
bool c = 0;
for (int i = 0; i < p.size(); i++) {
int j = (i + 1) % p.size();
if ((p[i].y <= q.y && q.y < p[j].y || p[j].y <= q.y && q.y < p[i].y) &&
q.x < p[i].x + (p[j].x - p[i].x) * (q.y - p[i].y) / (p[j].y - p[i].y))
c = !c;
}
return c;
}
bool PointOnPolygon(const vector<PT> &p, PT q) {
for (int i = 0; i < p.size(); i++)
if (dist2(ProjectPointSegment(p[i], p[(i + 1) % p.size()], q), q) < EPS)
return true;
return false;
}
vector<PT> pts;
int a[112345], b[112345];
int main() {
int n;
double l, r, m, p, q, ma = 0, mb = 0;
int i, iter;
cin >> n >> p >> q;
for (i = 0; i < n; ++i) {
scanf("%d", &a[i]);
scanf("%d", &b[i]);
ma = max(ma, (double)a[i]);
mb = max(mb, (double)b[i]);
}
l = 0;
r = 10000000;
for (int iter = 0; iter < 50; iter++) {
m = (l + r) / 2;
pts.clear();
for (i = 0; i < n; ++i) {
pts.push_back(PT(a[i], b[i]));
}
pts.push_back(PT(ma, 0));
pts.push_back(PT(0, mb));
pts.push_back(PT(0, 0));
ConvexHull(pts);
if (PointOnPolygon(pts, PT(p / m, q / m)) ||
PointInPolygon(pts, PT(p / m, q / m)) == 1) {
r = m;
} else {
l = m;
}
}
cout << setprecision(20);
cout << r << endl;
return 0;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
Do you know the story about the three musketeers? Anyway, you must help them now.
Richelimakieu is a cardinal in the city of Bearis. He found three brave warriors and called them the three musketeers. Athos has strength a, Borthos strength b, and Caramis has strength c.
The year 2015 is almost over and there are still n criminals to be defeated. The i-th criminal has strength ti. It's hard to defeat strong criminals — maybe musketeers will have to fight together to achieve it.
Richelimakieu will coordinate musketeers' actions. In each hour each musketeer can either do nothing or be assigned to one criminal. Two or three musketeers can be assigned to the same criminal and then their strengths are summed up. A criminal can be defeated in exactly one hour (also if two or three musketeers fight him). Richelimakieu can't allow the situation where a criminal has strength bigger than the sum of strengths of musketeers fighting him — a criminal would win then!
In other words, there are three ways to defeat a criminal.
* A musketeer of the strength x in one hour can defeat a criminal of the strength not greater than x. So, for example Athos in one hour can defeat criminal i only if ti ≤ a.
* Two musketeers can fight together and in one hour defeat a criminal of the strength not greater than the sum of strengths of these two musketeers. So, for example Athos and Caramis in one hour can defeat criminal i only if ti ≤ a + c. Note that the third remaining musketeer can either do nothing or fight some other criminal.
* Similarly, all three musketeers can fight together and in one hour defeat a criminal of the strength not greater than the sum of musketeers' strengths, i.e. ti ≤ a + b + c.
Richelimakieu doesn't want musketeers to fight during the New Year's Eve. Thus, he must coordinate their actions in order to minimize the number of hours till all criminals will be defeated.
Find the minimum number of hours to defeat all criminals. If musketeers can't defeat them all then print "-1" (without the quotes) instead.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the number of criminals.
The second line contains three integers a, b and c (1 ≤ a, b, c ≤ 108) — strengths of musketeers.
The third line contains n integers t1, t2, ..., tn (1 ≤ ti ≤ 108) — strengths of criminals.
Output
Print one line with the answer.
If it's impossible to defeat all criminals, print "-1" (without the quotes). Otherwise, print the minimum number of hours the three musketeers will spend on defeating all criminals.
Examples
Input
5
10 20 30
1 1 1 1 50
Output
2
Input
5
10 20 30
1 1 1 1 51
Output
3
Input
7
30 20 10
34 19 50 33 88 15 20
Output
-1
Input
6
10 5 10
10 9 5 25 20 5
Output
3
Note
In the first sample Athos has strength 10, Borthos 20, and Caramis 30. They can defeat all criminals in two hours:
* Borthos and Caramis should together fight a criminal with strength 50. In the same hour Athos can fight one of four criminals with strength 1.
* There are three criminals left, each with strength 1. Each musketeer can fight one criminal in the second hour.
In the second sample all three musketeers must together fight a criminal with strength 51. It takes one hour. In the second hour they can fight separately, each with one criminal. In the third hour one criminal is left and any of musketeers can fight him.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 100;
int n;
int a[10], t[maxn];
bool ok(int n, int m) {
int cnt = 0;
int b[3];
b[0] = b[1] = b[2] = m;
for (int i = n - 1; i >= 0; i--) {
if (t[i] <= a[0] && b[0]) {
b[0]--;
} else if (t[i] <= a[1] && b[1]) {
b[1]--;
} else if (t[i] <= a[2] && b[2]) {
b[2]--;
} else if (t[i] <= a[0] + a[1] && b[0] && b[1]) {
b[0]--, b[1]--;
cnt++;
} else if (t[i] <= a[0] + a[2] && b[0] && b[2]) {
b[0]--, b[2]--;
cnt++;
} else if (t[i] <= a[1] + a[2] && b[1] && b[2]) {
b[1]--, b[2]--;
cnt++;
} else if (t[i] <= a[0] + a[1] + a[2] && b[0] && b[1] && b[2]) {
b[0]--, b[1]--, b[2]--;
cnt++;
} else
return false;
}
if (cnt > m) return false;
return true;
}
int main() {
while (scanf("%d", &n) != EOF) {
scanf("%d %d %d", &a[0], &a[1], &a[2]);
sort(a, a + 3);
int sum = a[0] + a[1] + a[2];
bool find = false;
for (int i = 0; i < n; i++) {
scanf("%d", &t[i]);
if (t[i] > sum) find = true;
}
if (find) {
printf("-1\n");
continue;
}
sort(t, t + n);
int l = 1, r = n, m, ans = n;
while (l <= r) {
m = l + r >> 1;
if (ok(n, m)) {
r = m - 1;
ans = m;
} else {
l = m + 1;
}
}
printf("%d\n", ans);
}
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Given a string of length n s = s1, s2,…, sn and m queries. Each query qk (1 ≤ k ≤ m) is one of four types, "L ++", "L-", "R ++", "R-", and l [for the kth query qk. k] and r [k] are defined below.
* L ++: l [k] = l [k-1] + 1, r [k] = r [k-1]
* L-: l [k] = l [k-1] -1, r [k] = r [k-1]
* R ++: l [k] = l [k-1], r [k] = r [k-1] +1
* R-: l [k] = l [k-1], r [k] = r [k-1] -1
However, l [0] = r [0] = 1.
At this time, how many kinds of character strings are created for m substrings sl [k], sl [k] + 1,…, sr [k] -1, sr [k] (1 ≤ k ≤ m). Answer if you can.
Constraints
* The string s consists of a lowercase alphabet
* 1 ≤ n ≤ 3 x 105
* 1 ≤ m ≤ 3 × 105
* qk (1 ≤ k ≤ m) is one of "L ++", "L-", "R ++", "R-"
* 1 ≤ l [k] ≤ r [k] ≤ n (1 ≤ k ≤ m)
Input
Input is given in the following format
> n m
> s
> q1
> q2
>…
> qm
>
Output
Output the solution of the problem on one line
Examples
Input
5 4
abcde
R++
R++
L++
L--
Output
3
Input
4 6
abab
R++
L++
R++
L++
R++
L++
Output
4
Input
10 13
aacacbabac
R++
R++
L++
R++
R++
L++
L++
R++
R++
L--
L--
R--
R--
Output
11
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define REP(i,n) for(int i=0,_n=(int)(n);i<_n;++i)
#define ALL(v) (v).begin(),(v).end()
#define CLR(t,v) memset(t,(v),sizeof(t))
template<class T1,class T2>ostream& operator<<(ostream& os,const pair<T1,T2>&a){return os<<"("<<a.first<<","<<a.second<< ")";}
template<class T>void pv(T a,T b){for(T i=a;i!=b;++i)cout<<(*i)<<" ";cout<<endl;}
template<class T>void chmin(T&a,const T&b){if(a>b)a=b;}
template<class T>void chmax(T&a,const T&b){if(a<b)a=b;}
struct RollingHash {
typedef tuple<ll,ll,ll> HashType;
const ll mod1 = 999999893;
const ll mod2 = 999999929;
const ll mod3 = 999999937;
const ll b1 = 3422539;
const ll b2 = 1245103;
const ll b3 = 22961;
vector<ll> h1, h2, h3;
vector<ll> pow1, pow2, pow3;
RollingHash(const string &s) {
const int n = s.size();
h1.assign(n+1, 0);
h2.assign(n+1, 0);
h3.assign(n+1, 0);
pow1.assign(n+1, 1);
pow2.assign(n+1, 1);
pow3.assign(n+1, 1);
REP(i, n) {
h1[i+1] = (h1[i] * b1 + s[i]) % mod1;
h2[i+1] = (h2[i] * b2 + s[i]) % mod2;
h3[i+1] = (h3[i] * b3 + s[i]) % mod3;
pow1[i+1] = pow1[i] * b1 % mod1;
pow2[i+1] = pow2[i] * b2 % mod2;
pow3[i+1] = pow3[i] * b3 % mod3;
}
}
HashType get(int l, int r) {
ll v1 = ((h1[r] - h1[l] * pow1[r-l]) % mod1 + mod1) % mod1;
ll v2 = ((h2[r] - h2[l] * pow2[r-l]) % mod2 + mod2) % mod2;
ll v3 = ((h3[r] - h3[l] * pow3[r-l]) % mod3 + mod3) % mod3;
return HashType {v1, v2, v3};
}
};
int main2() {
int N, M; cin >> N >> M;
string s; cin >> s;
RollingHash hash(s);
int l = 0;
int r = 1;
set<RollingHash::HashType> st;
REP(_, M) {
string cmd; cin >> cmd;
if (cmd == "R++") { r++; }
if (cmd == "R--") { r--; }
if (cmd == "L++") { l++; }
if (cmd == "L--") { l--; }
auto key = hash.get(l, r);
st.insert(key);
}
cout << st.size() << endl;
return 0;
}
int main() {
for (;!cin.eof();cin>>ws)
main2();
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
One day, ZS the Coder wrote down an array of integers a with elements a1, a2, ..., an.
A subarray of the array a is a sequence al, al + 1, ..., ar for some integers (l, r) such that 1 ≤ l ≤ r ≤ n. ZS the Coder thinks that a subarray of a is beautiful if the bitwise xor of all the elements in the subarray is at least k.
Help ZS the Coder find the number of beautiful subarrays of a!
Input
The first line contains two integers n and k (1 ≤ n ≤ 106, 1 ≤ k ≤ 109) — the number of elements in the array a and the value of the parameter k.
The second line contains n integers ai (0 ≤ ai ≤ 109) — the elements of the array a.
Output
Print the only integer c — the number of beautiful subarrays of the array a.
Examples
Input
3 1
1 2 3
Output
5
Input
3 2
1 2 3
Output
3
Input
3 3
1 2 3
Output
2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const int N = 1e4 + 5;
struct Node {
int cnt;
Node* nxt[2];
Node() {
cnt = 0;
memset(nxt, 0, sizeof nxt);
}
};
Node* rt;
int n, k;
void add(int x) {
Node* cur = rt;
for (int i = 30; i >= 0; i--) {
bool b = ((1 << i) & x);
if (!cur->nxt[b]) cur->nxt[b] = new Node();
cur = cur->nxt[b];
cur->cnt++;
}
}
int query(int x) {
Node* cur = rt;
int cnt = 0;
for (int i = 30; i >= 0; i--) {
bool bx = (1 << i) & x, bk = (1 << i) & k;
if (!bk) {
if (cur->nxt[!bx]) {
cnt += cur->nxt[!bx]->cnt;
}
if (!cur->nxt[bx]) return cnt;
cur = cur->nxt[bx];
} else {
if (!cur->nxt[!bx]) return cnt;
cur = cur->nxt[!bx];
}
}
return cnt + cur->cnt;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
rt = new Node();
cin >> n >> k;
int arr[n];
long long ans = 0;
add(0);
for (int i = 0; i < n; i++) {
cin >> arr[i];
if (i) arr[i] ^= arr[i - 1];
ans += query(arr[i]);
add(arr[i]);
}
cout << ans;
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
The campus has m rooms numbered from 0 to m - 1. Also the x-mouse lives in the campus. The x-mouse is not just a mouse: each second x-mouse moves from room i to the room i ⋅ x mod{m} (in fact, it teleports from one room to another since it doesn't visit any intermediate room). Starting position of the x-mouse is unknown.
You are responsible to catch the x-mouse in the campus, so you are guessing about minimum possible number of traps (one trap in one room) you need to place. You are sure that if the x-mouse enters a trapped room, it immediately gets caught.
And the only observation you made is GCD (x, m) = 1.
Input
The only line contains two integers m and x (2 ≤ m ≤ 10^{14}, 1 ≤ x < m, GCD (x, m) = 1) — the number of rooms and the parameter of x-mouse.
Output
Print the only integer — minimum number of traps you need to install to catch the x-mouse.
Examples
Input
4 3
Output
3
Input
5 2
Output
2
Note
In the first example you can, for example, put traps in rooms 0, 2, 3. If the x-mouse starts in one of this rooms it will be caught immediately. If x-mouse starts in the 1-st rooms then it will move to the room 3, where it will be caught.
In the second example you can put one trap in room 0 and one trap in any other room since x-mouse will visit all rooms 1..m-1 if it will start in any of these rooms.
### Response
```cpp
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const int inf = 0x3f3f3f3f;
inline long long read() {
register long long x = 0, f = 1;
register char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) x = (x << 1) + (x << 3) + (c ^ 48);
return x * f;
}
void write(long long x) {
if (x < 0) x = -x, putchar('-');
if (x >= 10) write(x / 10);
putchar(x % 10 + '0');
}
void writeln(long long x) {
write(x);
puts("");
}
long long n, x, m, ans;
long long p[233], q[2333];
void d(long long x) {
for (int i = 2; 1ll * i * i <= m; ++i)
if (x % i == 0) {
q[++*q] = i;
while (x % i == 0) x /= i;
}
if (x > 1) q[++*q] = x;
}
long long times(long long x, long long y, long long mod) {
long long res =
(x * y - (long long)(((long double)x * y + 0.5) / mod) * mod) % mod;
res = (res % mod + mod) % mod;
return res;
}
long long qpow(long long a, long long b, long long mod) {
long long ans = 1;
for (; b; b >>= 1, a = times(a, a, mod))
if (b & 1) ans = times(ans, a, mod);
return ans;
}
long long phi(long long x) {
long long res = x;
for (register int i = (1); i <= int(*p); ++i)
if (x % p[i] == 0) res = res / p[i] * (p[i] - 1);
return res;
}
long long solve(long long a) {
long long mod = n / a, t = phi(mod), tmp = t, xd = x % mod;
for (int i = 1; i <= *q; ++i) {
while (tmp % q[i] == 0 && qpow(xd, tmp / q[i], mod) == 1) tmp /= q[i];
}
return t / tmp;
}
int main() {
n = read(), x = read(), m = n;
for (int i = 2; 1ll * i * i <= m; ++i)
if (m % i == 0) {
p[++*p] = i;
while (m % i == 0) m /= i;
}
if (m > 1) p[++*p] = m;
for (register int i = (1); i <= int(*p); ++i) {
q[++*q] = p[i];
d(p[i] - 1);
}
sort(q + 1, q + 1 + *q);
*q = unique(q + 1, q + 1 + *q) - q - 1;
for (int i = 1; 1ll * i * i <= n; ++i) {
if (n % i == 0) {
ans += solve(i);
if (n / i != i) ans += solve(n / i);
}
}
writeln(ans);
return 0;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
You are given the array a consisting of n positive (greater than zero) integers.
In one move, you can choose two indices i and j (i ≠ j) such that the absolute difference between a_i and a_j is no more than one (|a_i - a_j| ≤ 1) and remove the smallest of these two elements. If two elements are equal, you can remove any of them (but exactly one).
Your task is to find if it is possible to obtain the array consisting of only one element using several (possibly, zero) such moves or not.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 1000) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 50) — the length of a. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 100), where a_i is the i-th element of a.
Output
For each test case, print the answer: "YES" if it is possible to obtain the array consisting of only one element using several (possibly, zero) moves described in the problem statement, or "NO" otherwise.
Example
Input
5
3
1 2 2
4
5 5 5 5
3
1 2 4
4
1 3 4 4
1
100
Output
YES
YES
NO
NO
YES
Note
In the first test case of the example, we can perform the following sequence of moves:
* choose i=1 and j=3 and remove a_i (so a becomes [2; 2]);
* choose i=1 and j=2 and remove a_j (so a becomes [2]).
In the second test case of the example, we can choose any possible i and j any move and it doesn't matter which element we remove.
In the third test case of the example, there is no way to get rid of 2 and 4.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
bool oddPres = false;
bool evenPres = false;
for (int val : arr) {
if (val % 2 == 0) {
evenPres = true;
} else {
oddPres = true;
}
}
if (n % 2 == 0) {
if (evenPres && oddPres) {
cout << "YES";
} else {
cout << "NO";
}
} else {
if (oddPres) {
cout << "YES";
} else {
cout << "NO";
}
}
cout << "\n";
}
return 0;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
Polycarp is playing a new computer game. This game has n stones in a row. The stone on the position i has integer power a_i. The powers of all stones are distinct.
Each turn Polycarp can destroy either stone on the first position or stone on the last position (in other words, either the leftmost or the rightmost stone). When Polycarp destroys the stone it does not exist any more.
Now, Polycarp wants two achievements. He gets them if he destroys the stone with the least power and the stone with the greatest power. Help Polycarp find out what is the minimum number of moves he should make in order to achieve his goal.
For example, if n = 5 and a = [1, 5, 4, 3, 2], then Polycarp could make the following moves:
* Destroy the leftmost stone. After this move a = [5, 4, 3, 2];
* Destroy the rightmost stone. After this move a = [5, 4, 3];
* Destroy the leftmost stone. After this move a = [4, 3]. Polycarp destroyed the stones with the greatest and least power, so he can end the game.
Please note that in the example above, you can complete the game in two steps. For example:
* Destroy the leftmost stone. After this move a = [5, 4, 3, 2];
* Destroy the leftmost stone. After this move a = [4, 3, 2]. Polycarp destroyed the stones with the greatest and least power, so he can end the game.
Input
The first line contains an integer t (1 ≤ t ≤ 100). Then t test cases follow.
The first line of each test case contains one integer n (2 ≤ n ≤ 100) — the number of stones.
The second line contains n distinct integers a_1, a_2, …, a_n (1 ≤ a_i ≤ n) — the power of the stones.
Output
For each test case, output the minimum number of moves required to destroy the stones with the greatest and the lowest power.
Example
Input
5
5
1 5 4 3 2
8
2 1 3 4 5 6 8 7
8
4 2 3 1 8 6 7 5
4
3 4 2 1
4
2 3 1 4
Output
2
4
5
3
2
### Response
```cpp
#include "bits/stdc++.h"
using namespace std;
# define endl "\n"
#define pb emplace_back
#define mod 1000000007
int prime[10000001];
vector<int> primes;
void prime_seive()
{
for(int i=2;i*i<10000001;i++)
{
if(!prime[i])
{
for(int j=i*i;j<10000001;j+=i)
prime[j]=1;
}
}
}
void calc()
{
primes.reserve(1000001);
for(int i=2;i<10000001;i++)
{
if(!prime[i])
primes.push_back(i);
}
}
long long myceil_ll(long long a,long long b)
{
return (a+b-1)/b;
}
int myceil_int(int a,int b)
{
return (a+b-1)/b;
}
bool is_square(long long temp)
{
long long po=sqrtl(temp);
if(po*po==temp)
return true;
return false;
}
// bool equal(vector<int> diff)
// {
// for(int i=1;i<diff.size();i++)
// {
// if(diff[i]!=diff[i-1])return false;
// }
// return true;
// }
// int first_digit(long long num)
// {
// int count=0;
// while(num>=10)
// num/=10;
// return num;
// }
// long long fact(int num)
// {
// long long prod=1;
// for(int i=2;i<=num;i++)
// {
// prod*=i;
// prod%=mod;
// }
// return prod;
// }
// long long power(int a,int b)
// {
// long long ans=1;
// for(int i=0;i<b;i++)
// ans = (long long)ans*a;
// return ans;
// }
// bool cmp(const pair<int, int>& a,const pair<int, int>& b)
// {
// return (a.second > b.second);
// }
// // Function to sort the map according
// // to value in a (key-value) pairs
// void sorte(map<int, int>& M)
// {
// // Declare vector of pairs
// vector<pair<int, int> > A;
// // Copy key-value pair from Map
// // to vector of pairs
// for (auto& it : M) {
// A.push_back(it);
// }
// // Sort using comparator function
// sort(A.begin(), A.end());
// }
bool is_prime(long long num)
{
int is=true;
for(int i=2;i<=sqrt(num);i++)
{
if((num%i)==0)
{
return false;
}
}
return true;
}
bool is_valid(int row,int col,int n)
{
if(row<col || row<0 || row>=n || col<0 || col>=n)
return false;
return true;
}
// bool sizecom(const vector<int>& v1, const vector<int>& v2)
// {
// return v1.size() > v2.size();
// }
// void bubble_sort(int arr[],int n)
// {
// for(int i=0;i<n;i++)
// {
// for(int j=0;j<n-i-1;j++)
// {
// if(arr[j]<arr[j+1])
// swap(arr[j],arr[j+1]);
// }
// }
// }
// void insertion_sort(int arr[],int n)
// {
// for(int i=1;i<n;i++)
// {
// int j=i;
// while(j>0 && arr[j]<arr[j-1])
// swap(arr[j],arr[j-1]),j--;
// }
// }
// int partition(int arr[],int start,int end)
// {
// int pivot = arr[end];
// int idx = start-1;
// for(int i=start;i<end;i++)
// {
// if(arr[i]<pivot)
// {
// idx++;
// swap(arr[idx],arr[i]);
// }
// }
// swap(arr[idx+1],arr[end]);
// return idx+1;
// }
// void quick_sort(int arr[],int start,int end)
// {
// if(start>=end)return;
// int pi = partition(arr,start,end);
// quick_sort(arr,start,pi-1);
// quick_sort(arr,pi+1,end);
// }
void dbg_arr(int arr[],int n)
{
for(int i=0;i<n;i++)
cout << arr[i] << " ";
cout << endl;
}
void dbg_vec(vector<int>&v)
{
for(auto it:v)
cout << it << " ";
cout << endl;
}
void read_array(int arr[],int n)
{
for(int i=0;i<n;i++)
cin >> arr[i];
}
void write_array(int arr[],int n)
{
for(int i=0;i<n;i++)
cout << arr[i] << " ";
cout << endl;
}
// int len(long long num)
// {
// int count=0;
// while(num>0)
// {
// //count++;
// count+=(num%10);
// num/=10;
// }
// return count;
// }
void t_c()
{
int n;
cin >> n;
int arr[n];
read_array(arr,n);
int s_idx,l_idx;
for(int i=0;i<n;i++)
{
if(arr[i]==1)
s_idx = i;
if(arr[i]==n)
l_idx = i;
}
int c1,c2,c3;
// cout << l_idx << " " << s_idx << endl;
int mini = min(s_idx,l_idx);
int maxi = max(s_idx,l_idx);
if(mini == s_idx)
{
c1 = s_idx+1 + n-l_idx;
c2 = s_idx+1 + l_idx-s_idx;
c3 = n-l_idx + abs(s_idx-l_idx);
}
else
{
c1 = l_idx+1 + n-s_idx;
c2 = l_idx+1 + s_idx-l_idx;
c3 = n-s_idx + abs(s_idx-l_idx);
}
// cout << c1 << " " << c2 << " " << c3 << endl;
cout << min({c1,c2,c3}) << endl;
}
int main()
{
// prime_seive();
// calc();
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t=1;
cin >> t;
for(int i=0;i<t;i++)
{
t_c();
}
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
Alice got tired of playing the tag game by the usual rules so she offered Bob a little modification to it. Now the game should be played on an undirected rooted tree of n vertices. Vertex 1 is the root of the tree.
Alice starts at vertex 1 and Bob starts at vertex x (x ≠ 1). The moves are made in turns, Bob goes first. In one move one can either stay at the current vertex or travel to the neighbouring one.
The game ends when Alice goes to the same vertex where Bob is standing. Alice wants to minimize the total number of moves and Bob wants to maximize it.
You should write a program which will determine how many moves will the game last.
Input
The first line contains two integer numbers n and x (2 ≤ n ≤ 2·105, 2 ≤ x ≤ n).
Each of the next n - 1 lines contains two integer numbers a and b (1 ≤ a, b ≤ n) — edges of the tree. It is guaranteed that the edges form a valid tree.
Output
Print the total number of moves Alice and Bob will make.
Examples
Input
4 3
1 2
2 3
2 4
Output
4
Input
5 2
1 2
2 3
3 4
2 5
Output
6
Note
In the first example the tree looks like this:
<image>
The red vertex is Alice's starting position, the blue one is Bob's. Bob will make the game run the longest by standing at the vertex 3 during all the game. So here are the moves:
B: stay at vertex 3
A: go to vertex 2
B: stay at vertex 3
A: go to vertex 3
In the second example the tree looks like this:
<image>
The moves in the optimal strategy are:
B: go to vertex 3
A: go to vertex 2
B: go to vertex 4
A: go to vertex 3
B: stay at vertex 4
A: go to vertex 4
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 200010;
vector<int> adj[N];
int dist[N];
void prep(int u, int d = 0, int p = -1) {
dist[u] = d;
for (int v : adj[u])
if (v != p) {
prep(v, d + 1, u);
}
}
int dfs(int u, int d = 0, int p = -1) {
if (dist[u] <= d) return 2 * d;
int ans = 2 * dist[u];
for (int v : adj[u])
if (v != p) {
ans = max(ans, dfs(v, d + 1, u));
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
int n, x;
cin >> n >> x;
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
prep(1);
cout << dfs(x) << endl;
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
Simon and Antisimon play a game. Initially each player receives one fixed positive integer that doesn't change throughout the game. Simon receives number a and Antisimon receives number b. They also have a heap of n stones. The players take turns to make a move and Simon starts. During a move a player should take from the heap the number of stones equal to the greatest common divisor of the fixed number he has received and the number of stones left in the heap. A player loses when he cannot take the required number of stones (i. e. the heap has strictly less stones left than one needs to take).
Your task is to determine by the given a, b and n who wins the game.
Input
The only string contains space-separated integers a, b and n (1 ≤ a, b, n ≤ 100) — the fixed numbers Simon and Antisimon have received correspondingly and the initial number of stones in the pile.
Output
If Simon wins, print "0" (without the quotes), otherwise print "1" (without the quotes).
Examples
Input
3 5 9
Output
0
Input
1 1 100
Output
1
Note
The greatest common divisor of two non-negative integers a and b is such maximum positive integer k, that a is divisible by k without remainder and similarly, b is divisible by k without remainder. Let gcd(a, b) represent the operation of calculating the greatest common divisor of numbers a and b. Specifically, gcd(x, 0) = gcd(0, x) = x.
In the first sample the game will go like that:
* Simon should take gcd(3, 9) = 3 stones from the heap. After his move the heap has 6 stones left.
* Antisimon should take gcd(5, 6) = 1 stone from the heap. After his move the heap has 5 stones left.
* Simon should take gcd(3, 5) = 1 stone from the heap. After his move the heap has 4 stones left.
* Antisimon should take gcd(5, 4) = 1 stone from the heap. After his move the heap has 3 stones left.
* Simon should take gcd(3, 3) = 3 stones from the heap. After his move the heap has 0 stones left.
* Antisimon should take gcd(5, 0) = 5 stones from the heap. As 0 < 5, it is impossible and Antisimon loses.
In the second sample each player during each move takes one stone from the heap. As n is even, Antisimon takes the last stone and Simon can't make a move after that.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, x, a, b, result = 0, t, w;
cin >> a >> b >> n;
for (t = 1; n >= 0; t++) {
for (i = n; i >= 1; i--) {
if (n % i == 0 && a % i == 0) {
x = i;
break;
}
}
n = n - x;
if (n == 0) {
result = 0;
}
for (w = n; w >= 1; w--) {
if (n % w == 0 && b % w == 0) {
x = w;
break;
}
}
n = n - x;
if (n == 0) {
result = 1;
}
}
cout << result;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
The only difference between easy and hard versions is constraints.
Polycarp loves to listen to music, so he never leaves the player, even on the way home from the university. Polycarp overcomes the distance from the university to the house in exactly T minutes.
In the player, Polycarp stores n songs, each of which is characterized by two parameters: t_i and g_i, where t_i is the length of the song in minutes (1 ≤ t_i ≤ 15), g_i is its genre (1 ≤ g_i ≤ 3).
Polycarp wants to create such a playlist so that he can listen to music all the time on the way from the university to his home, and at the time of his arrival home, the playlist is over. Polycarp never interrupts songs and always listens to them from beginning to end. Thus, if he started listening to the i-th song, he would spend exactly t_i minutes on its listening. Polycarp also does not like when two songs of the same genre play in a row (i.e. successively/adjacently) or when the songs in his playlist are repeated.
Help Polycarpus count the number of different sequences of songs (their order matters), the total duration is exactly T, such that there are no two consecutive songs of the same genre in them and all the songs in the playlist are different.
Input
The first line of the input contains two integers n and T (1 ≤ n ≤ 15, 1 ≤ T ≤ 225) — the number of songs in the player and the required total duration, respectively.
Next, the n lines contain descriptions of songs: the i-th line contains two integers t_i and g_i (1 ≤ t_i ≤ 15, 1 ≤ g_i ≤ 3) — the duration of the i-th song and its genre, respectively.
Output
Output one integer — the number of different sequences of songs, the total length of exactly T, such that there are no two consecutive songs of the same genre in them and all the songs in the playlist are different. Since the answer may be huge, output it modulo 10^9 + 7 (that is, the remainder when dividing the quantity by 10^9 + 7).
Examples
Input
3 3
1 1
1 2
1 3
Output
6
Input
3 3
1 1
1 1
1 3
Output
2
Input
4 10
5 3
2 1
3 2
5 1
Output
10
Note
In the first example, Polycarp can make any of the 6 possible playlist by rearranging the available songs: [1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2] and [3, 2, 1] (indices of the songs are given).
In the second example, the first and second songs cannot go in succession (since they have the same genre). Thus, Polycarp can create a playlist in one of 2 possible ways: [1, 3, 2] and [2, 3, 1] (indices of the songs are given).
In the third example, Polycarp can make the following playlists: [1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1], [1, 4], [4, 1], [2, 3, 4] and [4, 3, 2] (indices of the songs are given).
### Response
```cpp
#include <bits/stdc++.h>
const long long mod = 1e9 + 7;
using namespace std;
long long dp[1 << 17][5], n, val[18], type[18], res = 0, t;
signed main() {
cin >> n >> t;
for (long long i = 1; i <= n; i++) {
cin >> val[i] >> type[i];
dp[1 << (i - 1)][type[i]] = 1;
}
for (long long i = 1; i < (1 << n); i++) {
for (long long last = 1; last <= 3; last++) {
for (long long j = 1; j <= n; j++) {
if ((i & (1 << (j - 1))) == 0 && last != type[j]) {
dp[i | (1 << (j - 1))][type[j]] =
(dp[i | (1 << (j - 1))][type[j]] + dp[i][last]) % mod;
}
}
long long sum = 0;
for (long long k = 1; k <= n; k++) {
if ((1 << (k - 1) & i) != 0) sum += val[k];
}
if (sum == t) res += dp[i][last] % mod;
res %= mod;
}
}
cout << res % mod;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
«One dragon. Two dragon. Three dragon», — the princess was counting. She had trouble falling asleep, and she got bored of counting lambs when she was nine.
However, just counting dragons was boring as well, so she entertained herself at best she could. Tonight she imagined that all dragons were here to steal her, and she was fighting them off. Every k-th dragon got punched in the face with a frying pan. Every l-th dragon got his tail shut into the balcony door. Every m-th dragon got his paws trampled with sharp heels. Finally, she threatened every n-th dragon to call her mom, and he withdrew in panic.
How many imaginary dragons suffered moral or physical damage tonight, if the princess counted a total of d dragons?
Input
Input data contains integer numbers k, l, m, n and d, each number in a separate line (1 ≤ k, l, m, n ≤ 10, 1 ≤ d ≤ 105).
Output
Output the number of damaged dragons.
Examples
Input
1
2
3
4
12
Output
12
Input
2
3
4
5
24
Output
17
Note
In the first case every first dragon got punched with a frying pan. Some of the dragons suffered from other reasons as well, but the pan alone would be enough.
In the second case dragons 1, 7, 11, 13, 17, 19 and 23 escaped unharmed.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int k, l, m, n, d;
cin >> k >> l >> m >> n >> d;
int count = d;
for (int i = 1; i <= d; i++) {
if (i % k != 0) {
if (i % l != 0) {
if (i % m != 0) {
if (i % n != 0) {
count--;
}
}
}
}
}
cout << count;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
The Ohgas are a prestigious family based on Hachioji. The head of the family, Mr. Nemochi Ohga, a famous wealthy man, wishes to increase his fortune by depositing his money to an operation company. You are asked to help Mr. Ohga maximize his profit by operating the given money during a specified period.
From a given list of possible operations, you choose an operation to deposit the given fund to. You commit on the single operation throughout the period and deposit all the fund to it. Each operation specifies an annual interest rate, whether the interest is simple or compound, and an annual operation charge. An annual operation charge is a constant not depending on the balance of the fund. The amount of interest is calculated at the end of every year, by multiplying the balance of the fund under operation by the annual interest rate, and then rounding off its fractional part. For compound interest, it is added to the balance of the fund under operation, and thus becomes a subject of interest for the following years. For simple interest, on the other hand, it is saved somewhere else and does not enter the balance of the fund under operation (i.e. it is not a subject of interest in the following years). An operation charge is then subtracted from the balance of the fund under operation. You may assume here that you can always pay the operation charge (i.e. the balance of the fund under operation is never less than the operation charge). The amount of money you obtain after the specified years of operation is called ``the final amount of fund.'' For simple interest, it is the sum of the balance of the fund under operation at the end of the final year, plus the amount of interest accumulated throughout the period. For compound interest, it is simply the balance of the fund under operation at the end of the final year.
Operation companies use C, C++, Java, etc., to perform their calculations, so they pay a special attention to their interest rates. That is, in these companies, an interest rate is always an integral multiple of 0.0001220703125 and between 0.0001220703125 and 0.125 (inclusive). 0.0001220703125 is a decimal representation of 1/8192. Thus, interest rates' being its multiples means that they can be represented with no errors under the double-precision binary representation of floating-point numbers.
For example, if you operate 1000000 JPY for five years with an annual, compound interest rate of 0.03125 (3.125 %) and an annual operation charge of 3000 JPY, the balance changes as follows.
The balance of the fund under operation (at the beginning of year) | Interest| The balance of the fund under operation (at the end of year)
---|---|---
A| B = A × 0.03125 (and rounding off fractions) | A + B - 3000
1000000| 31250| 1028250
1028250| 32132| 1057382
1057382| 33043| 1087425
1087425| 33982| 1118407
1118407| 34950| 1150357
After the five years of operation, the final amount of fund is 1150357 JPY.
If the interest is simple with all other parameters being equal, it looks like:
The balance of the fund under operation (at the beginning of year) | Interest | The balance of the fund under operation (at the end of year) | Cumulative interest
---|---|---|---
A| B = A × 0.03125 (and rounding off fractions)| A - 3000|
1000000| 31250| 997000| 31250
997000| 31156| 994000| 62406
994000| 31062| 991000| 93468
991000| 30968| 988000| 124436
988000| 30875| 985000| 155311
In this case the final amount of fund is the total of the fund under operation, 985000 JPY, and the cumulative interests, 155311 JPY, which is 1140311 JPY.
Input
The input consists of datasets. The entire input looks like:
> the number of datasets (=m)
> 1st dataset
> 2nd dataset
> ...
> m-th dataset
>
The number of datasets, m, is no more than 100. Each dataset is formatted as follows.
> the initial amount of the fund for operation
> the number of years of operation
> the number of available operations (=n)
> operation 1
> operation 2
> ...
> operation n
>
The initial amount of the fund for operation, the number of years of operation, and the number of available operations are all positive integers. The first is no more than 100000000, the second no more than 10, and the third no more than 100.
Each ``operation'' is formatted as follows.
> simple-or-compound annual-interest-rate annual-operation-charge
where simple-or-compound is a single character of either '0' or '1', with '0' indicating simple interest and '1' compound. annual-interest-rate is represented by a decimal fraction and is an integral multiple of 1/8192. annual-operation-charge is an integer not exceeding 100000.
Output
For each dataset, print a line having a decimal integer indicating the final amount of fund for the best operation. The best operation is the one that yields the maximum final amount among the available operations. Each line should not have any character other than this number.
You may assume the final balance never exceeds 1000000000. You may also assume that at least one operation has the final amount of the fund no less than the initial amount of the fund.
Example
Input
4
1000000
5
2
0 0.03125 3000
1 0.03125 3000
6620000
7
2
0 0.0732421875 42307
1 0.0740966796875 40942
39677000
4
4
0 0.0709228515625 30754
1 0.00634765625 26165
0 0.03662109375 79468
0 0.0679931640625 10932
10585000
6
4
1 0.0054931640625 59759
1 0.12353515625 56464
0 0.0496826171875 98193
0 0.0887451171875 78966
Output
1150357
10559683
50796918
20829397
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define rep(i,n) FOR(i,0,n)
#define pb emplace_back
typedef long long ll;
typedef pair<int,int> pint;
int main(){
int m;
cin>>m;
int d,y,n;
int f,c;
double p;
while(m--){
cin>>d>>y>>n;
int mx=0;
rep(i,n){
int td=d;
cin>>f>>p>>c;
if(f==0){
int cnt=0;
rep(j,y){
cnt+=p*td;
td-=c;
}
td+=cnt;
}
else{
rep(j,y){
td=p*td+td;
td-=c;
}
}
mx=max(mx,td);
}
cout<<mx<<endl;
}
return 0;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
Victor tries to write his own text editor, with word correction included. However, the rules of word correction are really strange.
Victor thinks that if a word contains two consecutive vowels, then it's kinda weird and it needs to be replaced. So the word corrector works in such a way: as long as there are two consecutive vowels in the word, it deletes the first vowel in a word such that there is another vowel right before it. If there are no two consecutive vowels in the word, it is considered to be correct.
You are given a word s. Can you predict what will it become after correction?
In this problem letters a, e, i, o, u and y are considered to be vowels.
Input
The first line contains one integer n (1 ≤ n ≤ 100) — the number of letters in word s before the correction.
The second line contains a string s consisting of exactly n lowercase Latin letters — the word before the correction.
Output
Output the word s after the correction.
Examples
Input
5
weird
Output
werd
Input
4
word
Output
word
Input
5
aaeaa
Output
a
Note
Explanations of the examples:
1. There is only one replace: weird <image> werd;
2. No replace needed since there are no two consecutive vowels;
3. aaeaa <image> aeaa <image> aaa <image> aa <image> a.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
string s;
char v[] = {'a', 'i', 'e', 'o', 'u', 'y'};
int f = 0;
cin >> s;
for (int i = 0; i < n - 1; i++)
for (int j = 0; j < 6; j++) {
if (s[i] == v[j])
for (int z = 0; z < 6; z++)
if (s[i + 1] == v[z]) {
s.erase(s.begin() + i + 1);
f = 1;
i--;
break;
}
if (f == 1) {
f = 0;
break;
}
}
cout << s;
return 0;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
Write a program that extracts n different numbers from the numbers 0 to 9 and outputs the number of combinations that add up to s. Each n number is from 0 to 9, and the same number cannot be used in one combination. For example, if n is 3 and s is 6, the combination of the three numbers totaling 6 is
1 + 2 + 3 = 6
0 + 1 + 5 = 6
0 + 2 + 4 = 6
There are three ways.
Input
Given multiple datasets. For each dataset, n (1 ≤ n ≤ 9) and s (0 ≤ s ≤ 100) are given on one line, separated by a single space. When both n and s are 0, it is the end of the input (in this case, the program is terminated without processing).
The number of datasets does not exceed 50.
Output
For each dataset, output the number of combinations in which the sum of n integers is s on one line.
Example
Input
3 6
3 1
0 0
Output
3
0
### Response
```cpp
#include <iostream>
using namespace std;
int count(int n,int s,int i)
{
if(n == 1){
if(i <= s && s < 10) return 1;
return 0;
}
int res = 0;
for(; i<10; i++){
res += count(n-1, s-i,i+1);
}
return res;
}
int main()
{
int n,s;
while(cin >> n >> s, n!=0){
int cnt = count(n,s,0);
cout << cnt << endl;
}
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
IT City company developing computer games invented a new way to reward its employees. After a new game release users start buying it actively, and the company tracks the number of sales with precision to each transaction. Every time when the next number of sales is divisible by all numbers from 2 to 10 every developer of this game gets a small bonus.
A game designer Petya knows that the company is just about to release a new game that was partly developed by him. On the basis of his experience he predicts that n people will buy the game during the first month. Now Petya wants to determine how many times he will get the bonus. Help him to know it.
Input
The only line of the input contains one integer n (1 ≤ n ≤ 1018) — the prediction on the number of people who will buy the game.
Output
Output one integer showing how many numbers from 1 to n are divisible by all numbers from 2 to 10.
Examples
Input
3000
Output
1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long x, y;
cin >> x;
y = x / 2520;
cout << y << endl;
return 0;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
Write a program which manipulates a sequence A = {a0, a1, . . . , an−1} with the following operations:
* update(s, t, x): change as, as+1, ..., at to x.
* find(i): output the value of ai.
Note that the initial values of ai (i = 0, 1, . . . , n−1) are 231-1.
Constraints
* 1 ≤ n ≤ 100000
* 1 ≤ q ≤ 100000
* 0 ≤ s ≤ t < n
* 0 ≤ i < n
* 0 ≤ x < 231−1
Input
n q
query1
query2
:
queryq
In the first line, n (the number of elements in A) and q (the number of queries) are given. Then, ith query queryi is given in the following format:
0 s t x
or
1 i
The first digit represents the type of the query. '0' denotes update(s, t, x) and '1' denotes find(i).
Output
For each find operation, print the value.
Examples
Input
3 5
0 0 1 1
0 1 2 3
0 2 2 2
1 0
1 1
Output
1
3
Input
1 3
1 0
0 0 0 5
1 0
Output
2147483647
5
### Response
```cpp
#include "bits/stdc++.h"
using namespace std;
#ifdef _DEBUG
#include "dump.hpp"
#else
#define dump(...)
#endif
//#define int long long
#define rep(i,a,b) for(int i=(a);i<(b);i++)
#define rrep(i,a,b) for(int i=(b)-1;i>=(a);i--)
#define all(c) begin(c),end(c)
const int INF = (1ll << 31) - 1;
const int MOD = (int)(1e9) + 7;
const double PI = acos(-1);
const double EPS = 1e-9;
template<class T> bool chmax(T &a, const T &b) { if (a < b) { a = b; return true; } return false; }
template<class T> bool chmin(T &a, const T &b) { if (a > b) { a = b; return true; } return false; }
template<typename T>
struct RangeUpdateQuery {
int n;
vector<int>d;
RangeUpdateQuery(int m) {
for (n = 1; n < m; n <<= 1);
d.assign(2 * n, INF);
}
int find(int i) {
update(i, i + 1);
return d[n + i];
}
void update(int a, int b, int x=-1, int k = 1, int l = 0, int r = -1) {
if (r < 0)r = n;
if (r <= a || b <= l)return;
else if (a <= l&&r <= b) {
if (x >= 0)d[k] = x;
return;
}
else {
if (d[k] != INF)d[2 * k] = d[2 * k + 1] = d[k], d[k] = INF;
update(a, b, x, 2 * k, l, (l + r) / 2);
update(a, b, x, 2 * k + 1, (l + r) / 2, r);
}
}
};
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, q; cin >> n >> q;
RangeUpdateQuery<int>ruq(n);
rep(i, 0, q) {
int com; cin >> com;
if (com) {
int x; cin >> x;
cout << ruq.find(x) << endl;
}
else {
int s, t, x; cin >> s >> t >> x;
ruq.update(s, t + 1, x);
}
}
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
Attention: we lost all the test cases for this problem, so instead of solving the problem, we need you to generate test cases. We're going to give you the answer, and you need to print a test case that produces the given answer. The original problem is in the following paragraph.
People don't use cash as often as they used to. Having a credit card solves some of the hassles of cash, such as having to receive change when you can't form the exact amount of money needed to purchase an item. Typically cashiers will give you as few coins as possible in change, but they don't have to. For example, if your change is 30 cents, a cashier could give you a 5 cent piece and a 25 cent piece, or they could give you three 10 cent pieces, or ten 1 cent pieces, two 5 cent pieces, and one 10 cent piece. Altogether there are 18 different ways to make 30 cents using only 1 cent pieces, 5 cent pieces, 10 cent pieces, and 25 cent pieces. Two ways are considered different if they contain a different number of at least one type of coin. Given the denominations of the coins and an amount of change to be made, how many different ways are there to make change?
As we mentioned before, we lost all the test cases for this problem, so we're actually going to give you the number of ways, and want you to produce a test case for which the number of ways is the given number. There could be many ways to achieve this (we guarantee there's always at least one), so you can print any, as long as it meets the constraints described below.
Input
Input will consist of a single integer A (1 ≤ A ≤ 105), the desired number of ways.
Output
In the first line print integers N and M (1 ≤ N ≤ 106, 1 ≤ M ≤ 10), the amount of change to be made, and the number of denominations, respectively.
Then print M integers D1, D2, ..., DM (1 ≤ Di ≤ 106), the denominations of the coins. All denominations must be distinct: for any i ≠ j we must have Di ≠ Dj.
If there are multiple tests, print any of them. You can print denominations in atbitrary order.
Examples
Input
18
Output
30 4
1 5 10 25
Input
3
Output
20 2
5 2
Input
314
Output
183 4
6 5 2 139
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int arr[(int)1e6];
int n;
int main() {
ios::sync_with_stdio(0);
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
for (int i = 1; i <= (int)1e6; i++) {
arr[i] = (i / 2) + 1;
}
cin >> n;
for (int i = 1; i <= (int)1e6; i++) {
if (arr[i] == n) {
cout << i << " " << 2 << endl;
break;
}
}
cout << 1 << " " << 2 << endl;
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
You a captain of a ship. Initially you are standing in a point (x_1, y_1) (obviously, all positions in the sea can be described by cartesian plane) and you want to travel to a point (x_2, y_2).
You know the weather forecast — the string s of length n, consisting only of letters U, D, L and R. The letter corresponds to a direction of wind. Moreover, the forecast is periodic, e.g. the first day wind blows to the side s_1, the second day — s_2, the n-th day — s_n and (n+1)-th day — s_1 again and so on.
Ship coordinates change the following way:
* if wind blows the direction U, then the ship moves from (x, y) to (x, y + 1);
* if wind blows the direction D, then the ship moves from (x, y) to (x, y - 1);
* if wind blows the direction L, then the ship moves from (x, y) to (x - 1, y);
* if wind blows the direction R, then the ship moves from (x, y) to (x + 1, y).
The ship can also either go one of the four directions or stay in place each day. If it goes then it's exactly 1 unit of distance. Transpositions of the ship and the wind add up. If the ship stays in place, then only the direction of wind counts. For example, if wind blows the direction U and the ship moves the direction L, then from point (x, y) it will move to the point (x - 1, y + 1), and if it goes the direction U, then it will move to the point (x, y + 2).
You task is to determine the minimal number of days required for the ship to reach the point (x_2, y_2).
Input
The first line contains two integers x_1, y_1 (0 ≤ x_1, y_1 ≤ 10^9) — the initial coordinates of the ship.
The second line contains two integers x_2, y_2 (0 ≤ x_2, y_2 ≤ 10^9) — the coordinates of the destination point.
It is guaranteed that the initial coordinates and destination point coordinates are different.
The third line contains a single integer n (1 ≤ n ≤ 10^5) — the length of the string s.
The fourth line contains the string s itself, consisting only of letters U, D, L and R.
Output
The only line should contain the minimal number of days required for the ship to reach the point (x_2, y_2).
If it's impossible then print "-1".
Examples
Input
0 0
4 6
3
UUU
Output
5
Input
0 3
0 0
3
UDD
Output
3
Input
0 0
0 1
1
L
Output
-1
Note
In the first example the ship should perform the following sequence of moves: "RRRRU". Then its coordinates will change accordingly: (0, 0) → (1, 1) → (2, 2) → (3, 3) → (4, 4) → (4, 6).
In the second example the ship should perform the following sequence of moves: "DD" (the third day it should stay in place). Then its coordinates will change accordingly: (0, 3) → (0, 3) → (0, 1) → (0, 0).
In the third example the ship can never reach the point (0, 1).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long n;
const long long maxn = 1e5 + 5;
string s;
pair<long long, long long> loc[maxn];
pair<long long, long long> dir[255];
pair<long long, long long> rd;
long long sx, sy, ex, ey;
bool check(long long mid) {
long long rod = mid / n;
long long mod = mid % n;
long long dtx = ex - rod * loc[n].first - loc[mod].first;
long long dty = ey - rod * loc[n].second - loc[mod].second;
return mid < abs(dtx) + abs(dty);
}
long long check2(long long mid) {
long long rod = mid / n;
long long mod = mid % n;
long long dtx = ex - rod * loc[n].first - loc[mod].first;
long long dty = ey - rod * loc[n].second - loc[mod].second;
if (mid < abs(dtx) + abs(dty))
return mid + 1;
else if (mid > abs(dtx) + abs(dty)) {
cout << 1;
return mid - 1;
} else
return mid;
}
signed main() {
cin >> sx >> sy >> ex >> ey;
ex -= sx, ey -= sy;
dir['U'] = {0, 1};
dir['D'] = {0, -1};
dir['L'] = {-1, 0};
dir['R'] = {1, 0};
cin >> n >> s;
for (long long i = 1; i <= n; ++i) {
loc[i].first = loc[i - 1].first + dir[s[i - 1]].first;
loc[i].second = loc[i - 1].second + dir[s[i - 1]].second;
rd.first += dir[s[i - 1]].first;
rd.second += dir[s[i - 1]].second;
}
long long r = 1e18, l = 0;
while (l < r) {
long long mid = (l + r + 1) >> 1;
if (check(mid))
l = mid;
else
r = mid - 1;
}
if (l > 2e17)
cout << -1;
else
cout << check2(l);
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
Broken crypto generator
JAG (Japanese Alumni Group) is a mysterious organization composed of many programmers, and in order to enter the building where the headquarters of this organization is located, it is necessary to solve the ciphertext generated by a certain machine every time. This ciphertext consists of the symbols'+','-','[',']' and the uppercase alphabet, and is represented by <Cipher> defined by the following BNF.
<Cipher> :: = <String> | <Cipher> <String>
<String> :: = <Letter> |'['<Cipher>']'
<Letter> :: ='+' <Letter> |'-' <Letter> |
'A' |'B' |'C' |'D' |'E' |'F' |'G' |'H' |'I' |'J' |'K' |'L' |'M '|
'N' |'O' |'P' |'Q' |'R' |'S' |'T' |'U' |'V' |'W' |'X' |'Y' |'Z '
Here, each symbol has the following meaning.
* + (Character): Represents the alphabet following that character (provided that the alphabet following'Z'is'A')
*-(Character): Represents the alphabet before that character (provided that the alphabet before'A'is'Z')
* [(Character string)]: Represents a character string that is horizontally inverted.
However, the machine that generates this ciphertext is currently out of order, and some letters of the alphabet in the ciphertext may be broken and unreadable. Unreadable characters are tentatively represented as'?'. As a result of the investigation, it was found that the method of filling the broken characters is such that the decrypted character string is the smallest in the dictionary order among the possible character strings after decoding. Your job is to decrypt this ciphertext correctly.
Input
The input consists of multiple datasets. Each dataset consists of one line containing a string in which some uppercase letters have been replaced with ‘?’ In the ciphertext defined by BNF above. You can assume that the length of each string is less than $ 80 $. You can also assume that the number of'?' In each dataset is greater than or equal to $ 0 $ and less than or equal to $ 3 $.
The end of the input is represented by a line containing only one character,'.'.
Output
For each data set, output the decrypted character string when the ciphertext is decrypted so that the decrypted character string is the smallest in the dictionary order.
Sample Input
A + A ++ A
Z-Z--Z + -Z
[ESREVER]
J ---? --- J
++++++++ A +++ Z ----------- A +++ Z
[[++-+-? [-++-? ++-+++ L]] [-+ ----- + -O]] ++++ --- + L
..
Output for Sample Input
ABC
ZYXZ
REVERSE
JAG
ICPC
JAPAN
Example
Input
A+A++A
Z-Z--Z+-Z
[ESREVER]
J---?---J
++++++++A+++Z-----------A+++Z
[[++-+--?[--++-?++-+++L]][-+-----+-O]]++++---+L
.
Output
ABC
ZYXZ
REVERSE
JAG
ICPC
JAPAN
### Response
```cpp
#include<bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(n);i++)
using namespace std;
int main(){
string s;
while(cin>>s && s!="."){
int n = s.size();
stack<string> st;
int k = 0;
string tmp;
rep(i,n){
if(s[i]=='['){
st.push(tmp);
tmp ="";
}else if(s[i]==']'){
auto x = st.top();
st.pop();
reverse(tmp.begin(),tmp.end());
tmp = x + tmp;
}else if(s[i]=='-'){
k--;
}else if(s[i]=='+'){
k++;
}else if(s[i]=='?'){
k = 0;
tmp.push_back('?');
}else{
char c = s[i];
if(k<0){
while(k!=0){
if(c=='A'){
c = 'Z';
}else{
c--;
}
k++;
}
}
if(k>0){
while(k!=0){
if(c=='Z'){
c = 'A';
}else{
c++;
}
k--;
}
}
tmp.push_back(c);
}
}
rep(i,tmp.size()){
if(tmp[i]=='?'){
tmp[i] = 'A';
}
}
cout << tmp << "\n";
}
return 0;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
Draw a rectangle which has a height of H cm and a width of W cm. Draw a 1-cm square by single '#'.
Constraints
* 1 ≤ H ≤ 300
* 1 ≤ W ≤ 300
Input
The input consists of multiple datasets. Each dataset consists of two integers H and W separated by a single space.
The input ends with two 0 (when both H and W are zero).
Output
For each dataset, print the rectangle made of H × W '#'.
Print a blank line after each dataset.
Example
Input
3 4
5 6
2 2
0 0
Output
####
####
####
######
######
######
######
######
##
##
### Response
```cpp
#include<stdio.h>
int main(void)
{
int a,s,d,i,j;
while(1){
scanf("%d %d",&a,&s);
if(a==0&&s==0) break;
for(i=0;i<a;i++){
for(j=0;j<s;j++)
printf("#");
printf("\n");
}
printf("\n");
}
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
We have N+1 integers: 10^{100}, 10^{100}+1, ..., 10^{100}+N.
We will choose K or more of these integers. Find the number of possible values of the sum of the chosen numbers, modulo (10^9+7).
Constraints
* 1 \leq N \leq 2\times 10^5
* 1 \leq K \leq N+1
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N K
Output
Print the number of possible values of the sum, modulo (10^9+7).
Examples
Input
3 2
Output
10
Input
200000 200001
Output
1
Input
141421 35623
Output
220280457
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main()
{
long long int i, n, k, sum=0;
cin>>n>>k;
for(i=k;i<=n+1;i++)
{
sum+=i*(n-i+1)+1;
sum=sum%1000000007;
}
cout<<sum<<endl;
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
If there is an integer not less than 0 satisfying the following conditions, print the smallest such integer; otherwise, print `-1`.
* The integer has exactly N digits in base ten. (We assume 0 to be a 1-digit integer. For other integers, leading zeros are not allowed.)
* The s_i-th digit from the left is c_i. \left(i = 1, 2, \cdots, M\right)
Constraints
* All values in input are integers.
* 1 \leq N \leq 3
* 0 \leq M \leq 5
* 1 \leq s_i \leq N
* 0 \leq c_i \leq 9
Input
Input is given from Standard Input in the following format:
N M
s_1 c_1
\vdots
s_M c_M
Output
Print the answer.
Examples
Input
3 3
1 7
3 2
1 7
Output
702
Input
3 2
2 1
2 3
Output
-1
Input
3 1
1 0
Output
-1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int arr[5];
int main()
{
int n,m;
cin >> n >> m;
for(int i=0;i<5;i++)arr[i]=-1;
while(m--)
{
int i,x;
cin >> i >> x;
if(arr[i]!=x and arr[i]!=-1)
{
cout << -1;
return 0;
}
arr[i]=x;
}
if(arr[1]==-1 and n>1)arr[1]=1;
else if(arr[1]==-1 and n==1)arr[1]=0;
for(int i=2;i<=n;i++)if(arr[i]==-1)arr[i]=0;
if(n>1 and arr[1]==0)
{
cout << -1;
return 0;
}
for(int i=1;i<=n;i++)cout << arr[i];
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
Snuke is introducing a robot arm with the following properties to his factory:
* The robot arm consists of m sections and m+1 joints. The sections are numbered 1, 2, ..., m, and the joints are numbered 0, 1, ..., m. Section i connects Joint i-1 and Joint i. The length of Section i is d_i.
* For each section, its mode can be specified individually. There are four modes: `L`, `R`, `D` and `U`. The mode of a section decides the direction of that section. If we consider the factory as a coordinate plane, the position of Joint i will be determined as follows (we denote its coordinates as (x_i, y_i)):
* (x_0, y_0) = (0, 0).
* If the mode of Section i is `L`, (x_{i}, y_{i}) = (x_{i-1} - d_{i}, y_{i-1}).
* If the mode of Section i is `R`, (x_{i}, y_{i}) = (x_{i-1} + d_{i}, y_{i-1}).
* If the mode of Section i is `D`, (x_{i}, y_{i}) = (x_{i-1}, y_{i-1} - d_{i}).
* If the mode of Section i is `U`, (x_{i}, y_{i}) = (x_{i-1}, y_{i-1} + d_{i}).
Snuke would like to introduce a robot arm so that the position of Joint m can be matched with all of the N points (X_1, Y_1), (X_2, Y_2), ..., (X_N, Y_N) by properly specifying the modes of the sections. Is this possible? If so, find such a robot arm and how to bring Joint m to each point (X_j, Y_j).
Constraints
* All values in input are integers.
* 1 \leq N \leq 1000
* -10^9 \leq X_i \leq 10^9
* -10^9 \leq Y_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
X_1 Y_1
X_2 Y_2
:
X_N Y_N
Output
If the condition can be satisfied, follow the following format. If the condition cannot be satisfied, print `-1`.
m
d_1 d_2 ... d_m
w_1
w_2
:
w_N
m and d_i are the configurations of the robot arm. Refer to the problem statement for what each of them means. Here, 1 \leq m \leq 40 and 1 \leq d_i \leq 10^{12} must hold. Also, m and d_i must all be integers.
w_j is a string of length m that represents the way to bring Joint m of the robot arm to point (X_j, Y_j). The i-th character of w_j should be one of the letters `L`, `R`, `D` and `U`, representing the mode of Section i.
Examples
Input
3
-1 0
0 3
2 -1
Output
2
1 2
RL
UU
DR
Input
5
0 0
1 0
2 0
3 0
4 0
Output
-1
Input
2
1 1
1 1
Output
2
1 1
RU
UR
Input
3
-7 -3
7 3
-3 -7
Output
5
3 1 4 1 5
LRDUL
RDULR
DULRD
### Response
```cpp
#include<cmath>
#include<cstdio>
#include<algorithm>
using namespace std;
const int MAXN=1005;
const int INF=1e9;
int n,X[MAXN],Y[MAXN];
int bi[100],l,f[5];
void Print(int x,int y){
for(int i=1;i<=l;i++){
if(abs(x)>abs(y)){
if(x<0)printf("D"),x+=bi[i];
else printf("U"),x-=bi[i];
}
else{
if(y<0)printf("L"),y+=bi[i];
else printf("R"),y-=bi[i];
}
}
puts("");
}
int main(){
scanf("%d",&n);
for(int i=1;i<=n;i++){
scanf("%d%d",&X[i],&Y[i]);
f[(X[i]+Y[i])%2]=1;
}
if(f[0]==f[1]){
printf("-1\n");
return 0;
}
l=0;
for(int i=30;i>=0;i--)
bi[++l]=(1<<i);
if(f[0])bi[++l]=1;
printf("%d\n",l);
for(int i=1;i<l;i++)
printf("%d ",bi[i]);
printf("%d\n",bi[l]);
for(int i=1;i<=n;i++)
Print(Y[i],X[i]);
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
You are given a string S consisting of `0` and `1`. Find the maximum integer K not greater than |S| such that we can turn all the characters of S into `0` by repeating the following operation some number of times.
* Choose a contiguous segment [l,r] in S whose length is at least K (that is, r-l+1\geq K must be satisfied). For each integer i such that l\leq i\leq r, do the following: if S_i is `0`, replace it with `1`; if S_i is `1`, replace it with `0`.
Constraints
* 1\leq |S|\leq 10^5
* S_i(1\leq i\leq N) is either `0` or `1`.
Input
Input is given from Standard Input in the following format:
S
Output
Print the maximum integer K such that we can turn all the characters of S into `0` by repeating the operation some number of times.
Examples
Input
010
Output
2
Input
100000000
Output
8
Input
00001111
Output
4
### Response
```cpp
#include<iostream>
#include<string>
#include<algorithm>
using namespace std;
int main() {
string S;
cin >> S;
int res = S.size();
int a = S.size();
for (int i = 1;i < S.size();i++) {
if (S[i] != S[i - 1])
res = min(res, max(i, a - i));
}
cout << res << endl;
return 0;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
Ari the monster is not an ordinary monster. She is the hidden identity of Super M, the Byteforces’ superhero. Byteforces is a country that consists of n cities, connected by n - 1 bidirectional roads. Every road connects exactly two distinct cities, and the whole road system is designed in a way that one is able to go from any city to any other city using only the given roads. There are m cities being attacked by humans. So Ari... we meant Super M have to immediately go to each of the cities being attacked to scare those bad humans. Super M can pass from one city to another only using the given roads. Moreover, passing through one road takes her exactly one kron - the time unit used in Byteforces.
<image>
However, Super M is not on Byteforces now - she is attending a training camp located in a nearby country Codeforces. Fortunately, there is a special device in Codeforces that allows her to instantly teleport from Codeforces to any city of Byteforces. The way back is too long, so for the purpose of this problem teleportation is used exactly once.
You are to help Super M, by calculating the city in which she should teleport at the beginning in order to end her job in the minimum time (measured in krons). Also, provide her with this time so she can plan her way back to Codeforces.
Input
The first line of the input contains two integers n and m (1 ≤ m ≤ n ≤ 123456) - the number of cities in Byteforces, and the number of cities being attacked respectively.
Then follow n - 1 lines, describing the road system. Each line contains two city numbers ui and vi (1 ≤ ui, vi ≤ n) - the ends of the road i.
The last line contains m distinct integers - numbers of cities being attacked. These numbers are given in no particular order.
Output
First print the number of the city Super M should teleport to. If there are many possible optimal answers, print the one with the lowest city number.
Then print the minimum possible time needed to scare all humans in cities being attacked, measured in Krons.
Note that the correct answer is always unique.
Examples
Input
7 2
1 2
1 3
1 4
3 5
3 6
3 7
2 7
Output
2
3
Input
6 4
1 2
2 3
2 4
4 5
4 6
2 4 5 6
Output
2
4
Note
In the first sample, there are two possibilities to finish the Super M's job in 3 krons. They are:
<image> and <image>.
However, you should choose the first one as it starts in the city with the lower number.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 512345, lgN = 20, rootN = 1123;
const double eps = 1e-11;
vector<int> cities;
int root = -1;
int dp[N];
bool visited[N], rem[N];
vector<int> adj[N];
void dfsTree(int v) {
int sum = 0;
auto it = lower_bound(cities.begin(), cities.end(), v);
if (it < cities.end() && *it == v) ++sum;
for (int i = 0; i < adj[v].size(); ++i) {
int u = adj[v][i];
if (visited[u]) continue;
visited[u] = true;
dfsTree(u);
sum += dp[u];
}
if (sum == 0)
rem[v] = true;
else if (sum == cities.size() && root == -1)
root = v;
else if (sum == cities.size())
rem[v] = true;
dp[v] = sum;
}
pair<int, int> bfsDistance(int src) {
memset(visited, false, sizeof visited);
queue<pair<int, int> > q;
q.push(make_pair(src, 0));
visited[src] = true;
pair<int, int> ret = make_pair(src, 0);
while (!q.empty()) {
int v = q.front().first, dist = q.front().second;
q.pop();
if (dist > ret.second || (dist == ret.second && v < ret.first))
ret = make_pair(v, dist);
for (int i = 0; i < adj[v].size(); ++i) {
int u = adj[v][i];
if (visited[u] || rem[u]) continue;
visited[u] = true;
q.push(make_pair(u, dist + 1));
}
}
return ret;
}
int main() {
int n, c;
scanf("%d %d", &n, &c);
int u, v;
for (int i = 1; i < n; ++i) {
scanf("%d %d", &u, &v);
adj[u].push_back(v), adj[v].push_back(u);
}
cities.resize(c);
for (int i = 0; i < cities.size(); ++i) scanf("%d", &cities[i]);
sort(cities.begin(), cities.end());
visited[1] = true;
dfsTree(1);
pair<int, int> x = bfsDistance(root);
pair<int, int> y = bfsDistance(x.first);
printf("%d\n", min(x.first, y.first));
int ct = 0;
for (int i = 1; i <= n; ++i)
if (!rem[i]) ++ct;
int ans = 2 * (ct - 1) - y.second;
printf("%d\n", ans);
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
There are n warriors in a row. The power of the i-th warrior is a_i. All powers are pairwise distinct.
You have two types of spells which you may cast:
1. Fireball: you spend x mana and destroy exactly k consecutive warriors;
2. Berserk: you spend y mana, choose two consecutive warriors, and the warrior with greater power destroys the warrior with smaller power.
For example, let the powers of warriors be [2, 3, 7, 8, 11, 5, 4], and k = 3. If you cast Berserk on warriors with powers 8 and 11, the resulting sequence of powers becomes [2, 3, 7, 11, 5, 4]. Then, for example, if you cast Fireball on consecutive warriors with powers [7, 11, 5], the resulting sequence of powers becomes [2, 3, 4].
You want to turn the current sequence of warriors powers a_1, a_2, ..., a_n into b_1, b_2, ..., b_m. Calculate the minimum amount of mana you need to spend on it.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 2 ⋅ 10^5) — the length of sequence a and the length of sequence b respectively.
The second line contains three integers x, k, y (1 ≤ x, y, ≤ 10^9; 1 ≤ k ≤ n) — the cost of fireball, the range of fireball and the cost of berserk respectively.
The third line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n). It is guaranteed that all integers a_i are pairwise distinct.
The fourth line contains m integers b_1, b_2, ..., b_m (1 ≤ b_i ≤ n). It is guaranteed that all integers b_i are pairwise distinct.
Output
Print the minimum amount of mana for turning the sequnce a_1, a_2, ..., a_n into b_1, b_2, ..., b_m, or -1 if it is impossible.
Examples
Input
5 2
5 2 3
3 1 4 5 2
3 5
Output
8
Input
4 4
5 1 4
4 3 1 2
2 4 3 1
Output
-1
Input
4 4
2 1 11
1 3 2 4
1 3 2 4
Output
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int a[N], b[N], vis[N][2], vid, n, m;
long long dp[N][2], x, k, y;
long long solve(int len, bool one) {
if (len < 0) return 1e16;
if (len == 0) return 0;
long long &ret = dp[len][one];
if (vis[len][one] == vid) return ret;
vis[len][one] = vid;
ret = 1e16;
if (len >= k) ret = min(ret, solve(len - k, one) + x);
if (len > 1 or (len == 1 and one)) ret = min(ret, solve(len - 1, one) + y);
return ret;
}
int main() {
++vid;
scanf("%d%d%lld%lld%lld", &n, &m, &x, &k, &y);
for (int i = 0; i < n; i++) scanf("%d", a + i);
for (int i = 0; i < m; i++) scanf("%d", b + i);
int ind = 0;
vector<int> pos, val;
pos.emplace_back(-1);
val.emplace_back(0);
for (int i = 0; i < n and ind < m; i++)
if (b[ind] == a[i]) pos.emplace_back(i), val.emplace_back(b[ind++]);
pos.emplace_back(n);
val.emplace_back(0);
if (ind != m) return puts("-1"), 0;
long long ans = 0;
for (int i = 1; i < pos.size(); i++) {
int mx = 0, l = pos[i - 1] + 1, r = pos[i], mxB = 0;
for (int j = l; j < r; j++) mx = max(mx, a[j]);
mxB = max(val[i - 1], val[i]);
long long temp = solve(pos[i] - pos[i - 1] - 1, (mxB > mx));
if (temp == 1e16) return puts("-1"), 0;
ans += temp;
}
printf("%lld\n", ans);
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
We will play a one-player game using a number line and N pieces.
First, we place each of these pieces at some integer coordinate.
Here, multiple pieces can be placed at the same coordinate.
Our objective is to visit all of the M coordinates X_1, X_2, ..., X_M with these pieces, by repeating the following move:
Move: Choose a piece and let x be its coordinate. Put that piece at coordinate x+1 or x-1.
Note that the coordinates where we initially place the pieces are already regarded as visited.
Find the minimum number of moves required to achieve the objective.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^5
* 1 \leq M \leq 10^5
* -10^5 \leq X_i \leq 10^5
* X_1, X_2, ..., X_M are all different.
Input
Input is given from Standard Input in the following format:
N M
X_1 X_2 ... X_M
Output
Find the minimum number of moves required to achieve the objective.
Examples
Input
2 5
10 12 1 2 14
Output
5
Input
3 7
-10 -3 0 9 -100 2 17
Output
19
Input
100 1
-100000
Output
0
### Response
```cpp
#include <iostream>
#include <algorithm>
#define MAX 100001
using namespace std;
int main(){
int N,M;
cin >> N >> M;
int x[MAX],l[MAX];
for(int i = 0;i < M;i++){
cin >> x[i];
}
sort(x,x+M);
for(int i = 0;i < M - 1;i++){
l[i] = x[i+1] - x[i];
}
sort(l,l+M-1);
int total = 0;
for(int i = 0;i < M - N;i++){
total+= l[i];
}
cout << total << endl;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
<image>
Input
The first line of the input is a string (between 1 and 50 characters long, inclusive). Each character will be a letter of English alphabet, lowercase or uppercase.
The second line of the input is an integer between 0 and 26, inclusive.
Output
Output the required string.
Examples
Input
AprilFool
14
Output
AprILFooL
### Response
```cpp
#include <bits/stdc++.h>
int asalmi(int x) {
int i, k = (int)sqrt(x);
for (i = 2; i <= k; i++)
if (x % i == 0) return 0;
return 1;
}
int ters(int x) {
int bas = 0, t = x, i, k = 0;
while (t) {
bas++;
t /= 10;
}
for (i = 1; i <= bas; i++) {
k *= 10;
k += x % 10;
x /= 10;
}
return k;
}
using namespace std;
long long m, n;
void read() {}
void solve() {
int n;
string s;
cin >> s >> n;
for (int i = 0; i <= int(s.size()) - 1; i += 1) {
s[i] = tolower(s[i]);
if (s[i] - 'a' < n) s[i] = toupper(s[i]);
}
cout << s << endl;
}
void write() { int i, j; }
int main() {
read();
solve();
write();
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
Jabber ID on the national Berland service «Babber» has a form <username>@<hostname>[/resource], where
* <username> — is a sequence of Latin letters (lowercase or uppercase), digits or underscores characters «_», the length of <username> is between 1 and 16, inclusive.
* <hostname> — is a sequence of word separated by periods (characters «.»), where each word should contain only characters allowed for <username>, the length of each word is between 1 and 16, inclusive. The length of <hostname> is between 1 and 32, inclusive.
* <resource> — is a sequence of Latin letters (lowercase or uppercase), digits or underscores characters «_», the length of <resource> is between 1 and 16, inclusive.
The content of square brackets is optional — it can be present or can be absent.
There are the samples of correct Jabber IDs: [email protected], [email protected]/contest.
Your task is to write program which checks if given string is a correct Jabber ID.
Input
The input contains of a single line. The line has the length between 1 and 100 characters, inclusive. Each characters has ASCII-code between 33 and 127, inclusive.
Output
Print YES or NO.
Examples
Input
[email protected]
Output
YES
Input
[email protected]/contest.icpc/12
Output
NO
### Response
```cpp
#include <bits/stdc++.h>
char str[110];
int ok(char ch) {
if (ch >= '0' && ch <= '9') return 1;
if (ch >= 'a' && ch <= 'z') return 1;
if (ch >= 'A' && ch <= 'Z') return 1;
if (ch == '_') return 1;
return 0;
}
int user(char *s, int len) {
int i;
if (len < 1 || len > 16) return 0;
for (i = 0; i < len; ++i)
if (!ok(s[i])) return 0;
return 1;
}
int host(char *s, int len) {
int i, p = 0;
if (len < 1 || len > 32) return 0;
for (i = 0; i < len; ++i) {
if (s[i] == '.') {
if (!user(s + p, i - p)) return 0;
p = i + 1;
}
}
if (!user(s + p, i - p)) return 0;
return 1;
}
int main() {
gets(str);
int n, i, len, p = 0, flag = 1;
len = strlen(str);
for (i = 0; i < len; ++i) {
if (str[i] == '@') {
if (user(str, i)) {
p = i + 1;
break;
} else {
flag = 0;
goto L;
}
}
}
if (i == len) {
flag = 0;
goto L;
}
for (; i < len; ++i) {
if (str[i] == '/') {
if (host(str + p, i - p)) {
p = i + 1;
break;
} else {
flag = 0;
goto L;
}
}
}
if (i == len) {
if (!host(str + p, i - p)) {
flag = 0;
}
} else {
if (!user(str + p, len - p)) flag = 0;
}
L:
printf("%s\n", flag ? "YES" : "NO");
return 0;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
You are given n numbers a1, a2, ..., an. You can perform at most k operations. For each operation you can multiply one of the numbers by x. We want to make <image> as large as possible, where <image> denotes the bitwise OR.
Find the maximum possible value of <image> after performing at most k operations optimally.
Input
The first line contains three integers n, k and x (1 ≤ n ≤ 200 000, 1 ≤ k ≤ 10, 2 ≤ x ≤ 8).
The second line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 109).
Output
Output the maximum value of a bitwise OR of sequence elements after performing operations.
Examples
Input
3 1 2
1 1 1
Output
3
Input
4 2 3
1 2 4 8
Output
79
Note
For the first sample, any possible choice of doing one operation will result the same three numbers 1, 1, 2 so the result is <image>.
For the second sample if we multiply 8 by 3 two times we'll get 72. In this case the numbers will become 1, 2, 4, 72 so the OR value will be 79 and is the largest possible result.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200000 + 10;
long long a[maxn], pre[maxn], suf[maxn];
long long power(int x, int k) {
long long ans = 1;
for (int i = 1; i <= k; i++) ans *= (long long)x;
return ans;
}
int main() {
int n, k, x;
scanf("%d%d%d", &n, &k, &x);
for (int i = 1; i <= n; i++) scanf("%I64d", &a[i]);
pre[0] = 0;
for (int i = 1; i <= n; i++) pre[i] = pre[i - 1] | a[i];
suf[n + 1] = 0;
for (int i = n; i >= 1; i--) suf[i] = suf[i + 1] | a[i];
long long mult = power(x, k);
long long best = 0;
for (int i = 1; i <= n; i++)
best = max(best, pre[i - 1] | suf[i + 1] | (a[i] * mult));
printf("%I64d\n", best);
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Nauuo is a girl who loves drawing circles.
One day she has drawn a circle and wanted to draw a tree on it.
The tree is a connected undirected graph consisting of n nodes and n-1 edges. The nodes are numbered from 1 to n.
Nauuo wants to draw a tree on the circle, the nodes of the tree should be in n distinct points on the circle, and the edges should be straight without crossing each other.
"Without crossing each other" means that every two edges have no common point or the only common point is an endpoint of both edges.
Nauuo wants to draw the tree using a permutation of n elements. A permutation of n elements is a sequence of integers p_1,p_2,…,p_n in which every integer from 1 to n appears exactly once.
After a permutation is chosen Nauuo draws the i-th node in the p_i-th point on the circle, then draws the edges connecting the nodes.
The tree is given, Nauuo wants to know how many permutations are there so that the tree drawn satisfies the rule (the edges are straight without crossing each other). She only wants to know the answer modulo 998244353, can you help her?
It is obvious that whether a permutation is valid or not does not depend on which n points on the circle are chosen.
Input
The first line contains a single integer n (2≤ n≤ 2⋅ 10^5) — the number of nodes in the tree.
Each of the next n-1 lines contains two integers u and v (1≤ u,v≤ n), denoting there is an edge between u and v.
It is guaranteed that the given edges form a tree.
Output
The output contains a single integer — the number of permutations suitable to draw the given tree on a circle satisfying the rule, modulo 998244353.
Examples
Input
4
1 2
1 3
2 4
Output
16
Input
4
1 2
1 3
1 4
Output
24
Note
Example 1
All valid permutations and their spanning trees are as follows.
<image>
Here is an example of invalid permutation: the edges (1,3) and (2,4) are crossed.
<image>
Example 2
Every permutation leads to a valid tree, so the answer is 4! = 24.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base ::sync_with_stdio(false);
;
cin.tie(NULL);
;
long long int t = 1;
while (t--) {
long long int n;
cin >> n;
vector<vector<long long int>> adj(n + 1);
vector<long long int> cnt(n + 1, 0);
long long int i, j, k;
for (i = 0; i < n - 1; i++) {
cin >> j >> k;
adj[j].push_back(k);
adj[k].push_back(j);
}
long long int ans = 1;
list<long long int> l;
l.push_back(1);
while (!l.empty()) {
long long int node = l.front();
l.pop_front();
for (auto nei : adj[node]) {
if (cnt[nei]) continue;
ans *= (cnt[node] + 1);
ans %= 998244353;
cnt[node]++;
cnt[nei]++;
l.push_back(nei);
}
}
cout << (ans * n) % 998244353 << "\n";
}
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
In number world, two different numbers are friends if they have a lot in common, but also each one has unique perks.
More precisely, two different numbers a and b are friends if gcd(a,b), (a)/(gcd(a,b)), (b)/(gcd(a,b)) can form sides of a triangle.
Three numbers a, b and c can form sides of a triangle if a + b > c, b + c > a and c + a > b.
In a group of numbers, a number is lonely if it doesn't have any friends in that group.
Given a group of numbers containing all numbers from 1, 2, 3, ..., n, how many numbers in that group are lonely?
Input
The first line contains a single integer t (1 ≤ t ≤ 10^6) - number of test cases.
On next line there are t numbers, n_i (1 ≤ n_i ≤ 10^6) - meaning that in case i you should solve for numbers 1, 2, 3, ..., n_i.
Output
For each test case, print the answer on separate lines: number of lonely numbers in group 1, 2, 3, ..., n_i.
Example
Input
3
1 5 10
Output
1
3
3
Note
For first test case, 1 is the only number and therefore lonely.
For second test case where n=5, numbers 1, 3 and 5 are lonely.
For third test case where n=10, numbers 1, 5 and 7 are lonely.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int a[1000005], b[1000005];
void seive() {
for (int i = 4; i <= 1000000; i += 2) a[i] = 1;
for (int i = 3; i * i <= 1000000; i += 2) {
if (a[i] == 0) {
for (int j = i * i; j <= 1000000; j += 2 * i) a[j] = 1;
}
}
int x = 0;
b[0] = b[1] = 0;
for (int i = 2; i <= 1000000; i++) {
if (a[i] == 0) x++;
b[i] = x;
}
}
int main() {
seive();
int t;
scanf("%d", &t);
int n;
while (t--) {
scanf("%d", &n);
int d = sqrt(n);
printf("%d\n", b[n] - b[d] + 1);
}
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
Ivan is a student at Berland State University (BSU). There are n days in Berland week, and each of these days Ivan might have some classes at the university.
There are m working hours during each Berland day, and each lesson at the university lasts exactly one hour. If at some day Ivan's first lesson is during i-th hour, and last lesson is during j-th hour, then he spends j - i + 1 hours in the university during this day. If there are no lessons during some day, then Ivan stays at home and therefore spends 0 hours in the university.
Ivan doesn't like to spend a lot of time in the university, so he has decided to skip some lessons. He cannot skip more than k lessons during the week. After deciding which lessons he should skip and which he should attend, every day Ivan will enter the university right before the start of the first lesson he does not skip, and leave it after the end of the last lesson he decides to attend. If Ivan skips all lessons during some day, he doesn't go to the university that day at all.
Given n, m, k and Ivan's timetable, can you determine the minimum number of hours he has to spend in the university during one week, if he cannot skip more than k lessons?
Input
The first line contains three integers n, m and k (1 ≤ n, m ≤ 500, 0 ≤ k ≤ 500) — the number of days in the Berland week, the number of working hours during each day, and the number of lessons Ivan can skip, respectively.
Then n lines follow, i-th line containing a binary string of m characters. If j-th character in i-th line is 1, then Ivan has a lesson on i-th day during j-th hour (if it is 0, there is no such lesson).
Output
Print the minimum number of hours Ivan has to spend in the university during the week if he skips not more than k lessons.
Examples
Input
2 5 1
01001
10110
Output
5
Input
2 5 0
01001
10110
Output
8
Note
In the first example Ivan can skip any of two lessons during the first day, so he spends 1 hour during the first day and 4 hours during the second day.
In the second example Ivan can't skip any lessons, so he spends 4 hours every day.
### Response
```cpp
#include <bits/stdc++.h>
const int inf = 0x3f3f3f3f;
char clas[505];
int sum[505];
int skip[505][505];
int cost[505][505];
int dp[505];
int MIN(int x, int y) {
if (x < y)
return x;
else
return y;
}
int MAX(int x, int y) {
if (x > y)
return x;
else
return y;
}
int main() {
int n, m, k, j, i, p, r, l, mi;
scanf("%d%d%d", &n, &m, &k);
for (i = 1; i <= n; i++) {
scanf("%s", clas + 1);
for (j = 1; j <= m; j++) {
if (clas[j] == '1') {
sum[i]++;
skip[i][sum[i]] = j;
}
}
for (p = 0; p <= sum[i] - 1; p++) {
mi = inf;
for (l = 0; l <= sum[i] - 1; l++) {
if (p - l < 0) break;
r = p - l;
mi = MIN(mi, skip[i][sum[i] - r] - skip[i][l + 1] + 1);
}
cost[i][p] = m - mi;
}
cost[i][sum[i]] = m;
}
for (i = 1; i <= n; i++)
for (j = k; j >= 0; j--)
for (p = 0; p <= MIN(sum[i], j); p++) {
dp[j] = MAX(dp[j], dp[j - p] + cost[i][p]);
}
printf("%d\n", n * m - dp[k]);
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Twilight Sparkle was playing Ludo with her friends Rainbow Dash, Apple Jack and Flutter Shy. But she kept losing. Having returned to the castle, Twilight Sparkle became interested in the dice that were used in the game.
The dice has m faces: the first face of the dice contains a dot, the second one contains two dots, and so on, the m-th face contains m dots. Twilight Sparkle is sure that when the dice is tossed, each face appears with probability <image>. Also she knows that each toss is independent from others. Help her to calculate the expected maximum number of dots she could get after tossing the dice n times.
Input
A single line contains two integers m and n (1 ≤ m, n ≤ 105).
Output
Output a single real number corresponding to the expected maximum. The answer will be considered correct if its relative or absolute error doesn't exceed 10 - 4.
Examples
Input
6 1
Output
3.500000000000
Input
6 3
Output
4.958333333333
Input
2 2
Output
1.750000000000
Note
Consider the third test example. If you've made two tosses:
1. You can get 1 in the first toss, and 2 in the second. Maximum equals to 2.
2. You can get 1 in the first toss, and 1 in the second. Maximum equals to 1.
3. You can get 2 in the first toss, and 1 in the second. Maximum equals to 2.
4. You can get 2 in the first toss, and 2 in the second. Maximum equals to 2.
The probability of each outcome is 0.25, that is expectation equals to:
<image>
You can read about expectation using the following link: http://en.wikipedia.org/wiki/Expected_value
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000 * 100 + 10;
const int MOD = 1000 * 1000 * 1000 + 7;
long double n, m;
long double Pow(long double a, int b) {
if (b == 0) return 1;
long double x = Pow(a, b / 2);
x *= x;
if (b % 2) x *= a;
return x;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
cout << fixed << setprecision(10);
cin >> m >> n;
long double ans = 0;
for (long double i = 1; i < m; i++) {
ans += Pow(i / m, n);
}
cout << m - ans;
return 0;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
You are given two integers n and k. You are asked to choose maximum number of distinct integers from 1 to n so that there is no subset of chosen numbers with sum equal to k.
A subset of a set is a set that can be obtained from initial one by removing some (possibly all or none) elements of it.
Input
The first line contains the number of test cases T (1 ≤ T ≤ 100).
Each of the next T lines contains two integers n and k (1 ≤ k ≤ n ≤ 1000) — the description of test cases.
Output
For each test case output two lines. In the first line output a single integer m — the number of chosen integers.
In the second line output m distinct integers from 1 to n — the chosen numbers.
If there are multiple answers, print any. You can print the numbers in any order.
Example
Input
3
3 2
5 3
1 1
Output
2
3 1
3
4 5 2
0
### Response
```cpp
#include<bits/stdc++.h>
#define pb push_back
#define fon(i,a,b) for(int i=a;i<b;i++)
using namespace std;
int main(){
int t;
cin>>t;
while(t--){
int n,k;
cin>>n>>k;
vector<int>x;
int m=0;
int i=n;
while(i>k){
x.pb(i);
i--;
m++;
}
if(k%2==0){
fon(j,k/2,k){
x.pb(j);
m++;
}
}
else{
fon(j,(k+1)/2,k){
x.pb(j);
m++;
}
}
cout<<m<<endl;
fon(j,0,m){
cout<<x[j]<<" ";
}
cout<<endl;
}
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
You are given a string of length n. Each character is one of the first p lowercase Latin letters.
You are also given a matrix A with binary values of size p × p. This matrix is symmetric (A_{ij} = A_{ji}). A_{ij} = 1 means that the string can have the i-th and j-th letters of Latin alphabet adjacent.
Let's call the string crisp if all of the adjacent characters in it can be adjacent (have 1 in the corresponding cell of matrix A).
You are allowed to do the following move. Choose any letter, remove all its occurrences and join the remaining parts of the string without changing their order. For example, removing letter 'a' from "abacaba" will yield "bcb".
The string you are given is crisp. The string should remain crisp after every move you make.
You are allowed to do arbitrary number of moves (possible zero). What is the shortest resulting string you can obtain?
Input
The first line contains two integers n and p (1 ≤ n ≤ 10^5, 1 ≤ p ≤ 17) — the length of the initial string and the length of the allowed prefix of Latin alphabet.
The second line contains the initial string. It is guaranteed that it contains only first p lowercase Latin letters and that is it crisp. Some of these p first Latin letters might not be present in the string.
Each of the next p lines contains p integer numbers — the matrix A (0 ≤ A_{ij} ≤ 1, A_{ij} = A_{ji}). A_{ij} = 1 means that the string can have the i-th and j-th letters of Latin alphabet adjacent.
Output
Print a single integer — the length of the shortest string after you make arbitrary number of moves (possible zero).
Examples
Input
7 3
abacaba
0 1 1
1 0 0
1 0 0
Output
7
Input
7 3
abacaba
1 1 1
1 0 0
1 0 0
Output
0
Input
7 4
bacadab
0 1 1 1
1 0 0 0
1 0 0 0
1 0 0 0
Output
5
Input
3 3
cbc
0 0 0
0 0 1
0 1 0
Output
0
Note
In the first example no letter can be removed from the initial string.
In the second example you can remove letters in order: 'b', 'c', 'a'. The strings on the intermediate steps will be: "abacaba" → "aacaa" → "aaaa" → "".
In the third example you can remove letter 'b' and that's it.
In the fourth example you can remove letters in order 'c', 'b', but not in the order 'b', 'c' because two letters 'c' can't be adjacent.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool upmin(T &x, T y) {
return y <= x ? x = y, 1 : 0;
}
template <typename T>
inline bool upmax(T &x, T y) {
return x <= y ? x = y, 1 : 0;
}
const long double eps = 1e-9;
const long double pi = acos(-1);
const int oo = 1 << 30;
const long long loo = 1ll << 60;
const int MAXN = 100005;
const int MAXM = 2000005;
const int MX = 5000;
const int mods = 998244353;
const int SZ = 131;
const int inv2 = (mods + 1) >> 1;
const int INF = 0x3f3f3f3f;
namespace FastIO {
constexpr int SIZE = (1 << 21) + 1;
int num = 0, f;
char ibuf[SIZE], obuf[SIZE], que[65], *iS, *iT, *oS = obuf,
*oT = obuf + SIZE - 1, c;
inline void flush() {
fwrite(obuf, 1, oS - obuf, stdout);
oS = obuf;
}
inline void putc(char c) {
*oS++ = c;
if (oS == oT) flush();
}
inline void getc(char &c) {
for (c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++);
!isalpha(c) && c != EOF;
c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++))
;
}
inline void reads(char *st) {
char c;
int n = 0;
getc(st[++n]);
for (c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++);
isalpha(c);
c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++))
st[++n] = c;
st[++n] = '\0';
}
template <class I>
inline void read(I &x) {
for (f = 1, c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++);
c < '0' || c > '9';
c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++))
if (c == '-') f = -1;
for (x = 0; c >= '0' && c <= '9';
c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++))
x = (x << 3) + (x << 1) + (c & 15);
x *= f;
}
template <class I>
inline void print(I x) {
if (x < 0) putc('-'), x = -x;
if (!x) putc('0');
while (x) que[++num] = x % 10 + 48, x /= 10;
while (num) putc(que[num--]);
}
inline void putstr(string st) {
for (int i = 0; i < (int)st.size(); ++i) putc(st[i]);
}
struct Flusher_ {
~Flusher_() { flush(); }
} io_Flusher_;
} // namespace FastIO
using FastIO ::print;
using FastIO ::putc;
using FastIO ::putstr;
using FastIO ::read;
using FastIO ::reads;
char st[MAXN];
int flag[1 << 17], cnt[17], s[1 << 17], f[1 << 17], g[1 << 17], id[17], wh[17],
n, m;
void addtag(int x, int y) {
int M = m - 1;
for (int i = 0; i < m; ++i) id[i] = i;
for (int i = y; i < m; ++i) id[i] = id[i + 1];
if (x != y) {
--M;
for (int i = x; i < m - 1; ++i) id[i] = id[i + 1];
}
for (int i = 0; i < M; ++i) wh[id[i]] = i;
for (int i = 0; i < 1 << M; ++i) g[i] = 0;
for (int i = 1, lst = 0, nw = 0; i <= n; ++i) {
if (st[i] - 'a' != x && st[i] - 'a' != y) {
nw |= 1 << wh[st[i] - 'a'];
continue;
}
if (lst && (st[lst] != st[i] || x == y)) g[nw] = 1;
lst = i, nw = 0;
}
for (int i = 0; i < M; ++i)
for (int j = 0; j < 1 << M; ++j)
if (!((j >> i) & 1)) g[j ^ (1 << i)] |= g[j];
for (int i = 0; i < 1 << M; ++i) {
if (!g[i]) continue;
int t = 0;
for (int j = 0; j < M; ++j)
if ((i >> j) & 1) t |= 1 << id[j];
flag[t] = 1;
}
}
int main() {
read(n), read(m), reads(st);
for (int i = 1; i <= n; ++i) ++cnt[st[i] - 'a'];
for (int i = 0; i < m; ++i)
for (int j = 0, X; j < m; ++j) {
read(X);
if (X == 1) continue;
if (i <= j) addtag(i, j);
}
f[0] = 1;
for (int i = 0; i < 1 << m; ++i) {
for (int j = 0; j < m; ++j)
if ((i >> j) & 1) {
s[i] = s[i ^ (1 << j)] + cnt[j];
}
if (flag[i]) {
f[i] = 0;
continue;
}
for (int j = 0; j < m; ++j)
if (!((i >> j) & 1)) f[i | (1 << j)] |= f[i];
}
int ans = 0;
for (int i = 0; i < 1 << m; ++i)
if (f[i]) upmax(ans, s[i]);
print(n - ans);
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Everybody knows of [spaghetti sort](https://en.wikipedia.org/wiki/Spaghetti_sort). You decided to implement an analog sorting algorithm yourself, but as you survey your pantry you realize you're out of spaghetti! The only type of pasta you have is ravioli, but you are not going to let this stop you...
You come up with the following algorithm. For each number in the array ai, build a stack of ai ravioli. The image shows the stack for ai = 4.
<image>
Arrange the stacks in one row in the order in which the corresponding numbers appear in the input array. Find the tallest one (if there are several stacks of maximal height, use the leftmost one). Remove it and add its height to the end of the output array. Shift the stacks in the row so that there is no gap between them. Repeat the procedure until all stacks have been removed.
At first you are very happy with your algorithm, but as you try it on more inputs you realize that it doesn't always produce the right sorted array. Turns out when two stacks of ravioli are next to each other (at any step of the process) and differ in height by two or more, the top ravioli of the taller stack slides down on top of the lower stack.
Given an input array, figure out whether the described algorithm will sort it correctly.
Input
The first line of input contains a single number n (1 ≤ n ≤ 10) — the size of the array.
The second line of input contains n space-separated integers ai (1 ≤ ai ≤ 100) — the elements of the array.
Output
Output "YES" if the array can be sorted using the described procedure and "NO" if it can not.
Examples
Input
3
1 2 3
Output
YES
Input
3
3 1 2
Output
NO
Note
In the second example the array will change even before the tallest stack is chosen for the first time: ravioli from stack of height 3 will slide on the stack of height 1, and the algorithm will output an array {2, 2, 2}.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[15];
a[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i <= n; i++) {
int max = 0;
for (int i = 1; i < n - i + 1; i++) {
if (abs(a[i] - a[i + 1]) >= 2) {
cout << "NO";
return false;
}
}
for (int i = 1; i <= n; i++) {
if (a[i] > a[max]) {
max = i;
}
}
int tmp = a[max];
for (int i = max + 1; i <= n; i++) {
a[i - 1] = a[i];
}
a[n] = tmp;
}
cout << "YES";
return 0;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
It is a balmy spring afternoon, and Farmer John's n cows are ruminating about link-cut cacti in their stalls. The cows, labeled 1 through n, are arranged so that the i-th cow occupies the i-th stall from the left. However, Elsie, after realizing that she will forever live in the shadows beyond Bessie's limelight, has formed the Mischievous Mess Makers and is plotting to disrupt this beautiful pastoral rhythm. While Farmer John takes his k minute long nap, Elsie and the Mess Makers plan to repeatedly choose two distinct stalls and swap the cows occupying those stalls, making no more than one swap each minute.
Being the meticulous pranksters that they are, the Mischievous Mess Makers would like to know the maximum messiness attainable in the k minutes that they have. We denote as pi the label of the cow in the i-th stall. The messiness of an arrangement of cows is defined as the number of pairs (i, j) such that i < j and pi > pj.
Input
The first line of the input contains two integers n and k (1 ≤ n, k ≤ 100 000) — the number of cows and the length of Farmer John's nap, respectively.
Output
Output a single integer, the maximum messiness that the Mischievous Mess Makers can achieve by performing no more than k swaps.
Examples
Input
5 2
Output
10
Input
1 10
Output
0
Note
In the first sample, the Mischievous Mess Makers can swap the cows in the stalls 1 and 5 during the first minute, then the cows in stalls 2 and 4 during the second minute. This reverses the arrangement of cows, giving us a total messiness of 10.
In the second sample, there is only one cow, so the maximum possible messiness is 0.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
istream &input = cin;
ostream &output = cout;
long long N = 0, K = 0;
input >> N >> K;
if (K > N / 2) K = N / 2;
long long result = 0;
if (K > 0) {
result = ((N - 1) + (N - 2 * K)) * K;
}
output << result << endl;
return 0;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
Allen wants to enter a fan zone that occupies a round square and has n entrances.
There already is a queue of a_i people in front of the i-th entrance. Each entrance allows one person from its queue to enter the fan zone in one minute.
Allen uses the following strategy to enter the fan zone:
* Initially he stands in the end of the queue in front of the first entrance.
* Each minute, if he is not allowed into the fan zone during the minute (meaning he is not the first in the queue), he leaves the current queue and stands in the end of the queue of the next entrance (or the first entrance if he leaves the last entrance).
Determine the entrance through which Allen will finally enter the fan zone.
Input
The first line contains a single integer n (2 ≤ n ≤ 10^5) — the number of entrances.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 10^9) — the number of people in queues. These numbers do not include Allen.
Output
Print a single integer — the number of entrance that Allen will use.
Examples
Input
4
2 3 2 0
Output
3
Input
2
10 10
Output
1
Input
6
5 2 6 5 7 4
Output
6
Note
In the first example the number of people (not including Allen) changes as follows: [2, 3, 2, 0] → [1, 2, 1, 0] → [0, 1, 0, 0]. The number in bold is the queue Alles stands in. We see that he will enter the fan zone through the third entrance.
In the second example the number of people (not including Allen) changes as follows: [10, 10] → [9, 9] → [8, 8] → [7, 7] → [6, 6] → \\\ [5, 5] → [4, 4] → [3, 3] → [2, 2] → [1, 1] → [0, 0].
In the third example the number of people (not including Allen) changes as follows: [5, 2, 6, 5, 7, 4] → [4, 1, 5, 4, 6, 3] → [3, 0, 4, 3, 5, 2] → \\\ [2, 0, 3, 2, 4, 1] → [1, 0, 2, 1, 3, 0] → [0, 0, 1, 0, 2, 0].
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long a[100005];
int main() {
int n, m = 0;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
a[i] -= i;
if (a[i] <= 0) {
cout << i + 1 << endl;
m = 1;
break;
}
}
if (m == 0) {
long long mmin;
if (a[0] % n == 0)
mmin = a[0] / n;
else
mmin = a[0] / n + 1;
for (int i = 0; i < n; i++) {
if (a[i] % n == 0)
a[i] = a[i] / n;
else
a[i] = a[i] / n + 1;
mmin = min(mmin, a[i]);
}
for (int i = 0; i < n; i++) {
if (a[i] == mmin) {
cout << i + 1 << endl;
break;
}
}
}
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Vasya likes everything infinite. Now he is studying the properties of a sequence s, such that its first element is equal to a (s1 = a), and the difference between any two neighbouring elements is equal to c (si - si - 1 = c). In particular, Vasya wonders if his favourite integer b appears in this sequence, that is, there exists a positive integer i, such that si = b. Of course, you are the person he asks for a help.
Input
The first line of the input contain three integers a, b and c ( - 109 ≤ a, b, c ≤ 109) — the first element of the sequence, Vasya's favorite number and the difference between any two neighbouring elements of the sequence, respectively.
Output
If b appears in the sequence s print "YES" (without quotes), otherwise print "NO" (without quotes).
Examples
Input
1 7 3
Output
YES
Input
10 10 0
Output
YES
Input
1 -4 5
Output
NO
Input
0 60 50
Output
NO
Note
In the first sample, the sequence starts from integers 1, 4, 7, so 7 is its element.
In the second sample, the favorite integer of Vasya is equal to the first element of the sequence.
In the third sample all elements of the sequence are greater than Vasya's favorite integer.
In the fourth sample, the sequence starts from 0, 50, 100, and all the following elements are greater than Vasya's favorite integer.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (c == 0) {
if (b == a)
puts("YES");
else
puts("NO");
} else {
if ((b - a) % c == 0 && (b - a) / c >= 0)
puts("YES");
else
puts("NO");
}
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
This contest, AtCoder Beginner Contest, is abbreviated as ABC.
When we refer to a specific round of ABC, a three-digit number is appended after ABC. For example, ABC680 is the 680th round of ABC.
What is the abbreviation for the N-th round of ABC? Write a program to output the answer.
Constraints
* 100 ≤ N ≤ 999
Input
Input is given from Standard Input in the following format:
N
Output
Print the abbreviation for the N-th round of ABC.
Examples
Input
100
Output
ABC100
Input
425
Output
ABC425
Input
999
Output
ABC999
### Response
```cpp
#include <iostream>
using namespace std;
int main(){
int num;
cin >> num;
cout <<"ABC" << num;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
Dreamoon likes sequences very much. So he created a problem about the sequence that you can't find in OEIS:
You are given two integers d, m, find the number of arrays a, satisfying the following constraints:
* The length of a is n, n ≥ 1
* 1 ≤ a_1 < a_2 < ... < a_n ≤ d
* Define an array b of length n as follows: b_1 = a_1, ∀ i > 1, b_i = b_{i - 1} ⊕ a_i, where ⊕ is the bitwise exclusive-or (xor). After constructing an array b, the constraint b_1 < b_2 < ... < b_{n - 1} < b_n should hold.
Since the number of possible arrays may be too large, you need to find the answer modulo m.
Input
The first line contains an integer t (1 ≤ t ≤ 100) denoting the number of test cases in the input.
Each of the next t lines contains two integers d, m (1 ≤ d, m ≤ 10^9).
Note that m is not necessary the prime!
Output
For each test case, print the number of arrays a, satisfying all given constrains, modulo m.
Example
Input
10
1 1000000000
2 999999999
3 99999998
4 9999997
5 999996
6 99995
7 9994
8 993
9 92
10 1
Output
1
3
5
11
17
23
29
59
89
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int d, m;
cin >> d >> m;
long long ans = 1;
for (int i = 0; i < 30; i++) {
if (d < (1 << i)) break;
ans = ans * (min((1 << (i + 1)) - 1, d) - (1 << i) + 2) % m;
}
ans--;
if (ans < 0) ans += m;
cout << ans << endl;
}
return 0;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
Ujan has a lot of useless stuff in his drawers, a considerable part of which are his math notebooks: it is time to sort them out. This time he found an old dusty graph theory notebook with a description of a graph.
It is an undirected weighted graph on n vertices. It is a complete graph: each pair of vertices is connected by an edge. The weight of each edge is either 0 or 1; exactly m edges have weight 1, and all others have weight 0.
Since Ujan doesn't really want to organize his notes, he decided to find the weight of the minimum spanning tree of the graph. (The weight of a spanning tree is the sum of all its edges.) Can you find the answer for Ujan so he stops procrastinating?
Input
The first line of the input contains two integers n and m (1 ≤ n ≤ 10^5, 0 ≤ m ≤ min((n(n-1))/(2),10^5)), the number of vertices and the number of edges of weight 1 in the graph.
The i-th of the next m lines contains two integers a_i and b_i (1 ≤ a_i, b_i ≤ n, a_i ≠ b_i), the endpoints of the i-th edge of weight 1.
It is guaranteed that no edge appears twice in the input.
Output
Output a single integer, the weight of the minimum spanning tree of the graph.
Examples
Input
6 11
1 3
1 4
1 5
1 6
2 3
2 4
2 5
2 6
3 4
3 5
3 6
Output
2
Input
3 0
Output
0
Note
The graph from the first sample is shown below. Dashed edges have weight 0, other edges have weight 1. One of the minimum spanning trees is highlighted in orange and has total weight 2.
<image>
In the second sample, all edges have weight 0 so any spanning tree has total weight 0.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5;
int N, M;
set<int> to[MAXN + 1];
void solve() {
int ans = 0;
set<int> nvis;
for (int i = 1; i <= N; i++) nvis.insert(i);
for (int s = 1; s <= N; s++)
if (nvis.find(s) != nvis.end()) {
queue<int> q;
nvis.erase(nvis.find(s));
q.push(s);
while (!q.empty()) {
int u = q.front();
q.pop();
set<int> tmp = nvis;
for (int v : tmp)
if (to[u].find(v) == to[u].end()) {
nvis.erase(nvis.find(v));
q.push(v);
}
}
ans++;
}
printf("%d\n", ans - 1);
}
int main(void) {
while (~scanf("%d%d", &N, &M)) {
int a, b;
for (int i = 1; i <= N; i++) to[i].clear();
for (int i = 0; i < M; i++) {
scanf("%d%d", &a, &b);
to[a].insert(b);
to[b].insert(a);
}
solve();
}
return 0;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
The Prodiggers are quite a cool band and for this reason, they have been the surprise guest at the ENTER festival for the past 80 years. At the beginning of their careers, they weren’t so successful, so they had to spend time digging channels to earn money; hence the name. Anyway, they like to tour a lot and have surprising amounts of energy to do extremely long tours. However, they hate spending two consecutive days without having a concert, so they would like to avoid it.
A tour is defined by a sequence of concerts and days-off. You need to count in how many ways The Prodiggers can select k different tours of the same length between l and r.
For example if k = 2, l = 1 and r = 2, if we define concert day as {1} and day-off as {0}, here are all possible tours: {0}, {1}, {00}, {01}, {10}, {11}. But tour 00 can not be selected because it has 2 days-off in a row. Now, we need to count in how many ways we can select k = 2 tours of the same length in range [1;2]. Here they are: {0,1}; {01,10}; {01,11}; {10,11}.
Since their schedule is quite busy, they want you to tell them in how many ways can do that, modulo 1 000 000 007 (109 + 7).
Input
The first line of the input contains three integers k, l and r (1 ≤ k ≤ 200, 1 ≤ l ≤ r ≤ 1018).
Output
Output a single number: the number of ways to select k different tours of the same length, modulo 1 000 000 007.
Example
Input
1 1 2
Output
5
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
inline int add(const int& a, const int& b) {
return a + b >= mod ? a + b - mod : a + b;
}
inline int dec(const int& a, const int& b) {
return a >= b ? a - b : a - b + mod;
}
inline int mul(const int& a, const int& b) { return (long long)a * b % mod; }
inline void Add(int& a, const int& b) {
a = a + b >= mod ? a + b - mod : a + b;
}
inline void Dec(int& a, const int& b) { a = a >= b ? a - b : a - b + mod; }
inline void Mul(int& a, const int& b) { a = (long long)a * b % mod; }
inline int ksm(int a, int p) {
int ret = 1;
for (; p; p >>= 1, a = mul(a, a))
if (p & 1) Mul(ret, a);
return ret;
}
const int N = 205;
struct cp {
int x, y;
cp(int x = 0, int y = 0) : x(x), y(y) {}
friend inline cp operator+(const cp& a, const cp& b) {
return cp(add(a.x, b.x), add(a.y, b.y));
}
friend inline cp operator-(const cp& a, const cp& b) {
return cp(dec(a.x, b.x), dec(a.y, b.y));
}
friend inline cp operator*(const cp& a, const cp& b) {
return cp(add(mul(a.x, b.x), mul(5, mul(a.y, b.y))),
add(mul(a.x, b.y), mul(a.y, b.x)));
}
friend inline cp operator*(const cp& a, const int& b) {
return cp(mul(a.x, b), mul(a.y, b));
}
friend inline cp operator/(const cp& a, const cp& b) {
int t = ksm(dec(mul(b.x, b.x), mul(5, mul(b.y, b.y))), mod - 2);
return cp(mul(t, dec(mul(a.x, b.x), mul(5, mul(a.y, b.y)))),
mul(t, dec(mul(a.y, b.x), mul(a.x, b.y))));
}
friend inline cp operator^(cp a, int p) {
cp ret = cp(1, 0);
for (; p; p >>= 1, a = a * a)
if (p & 1) ret = ret * a;
return ret;
}
friend inline cp operator^(cp a, long long p) {
cp ret = cp(1, 0);
for (; p; p >>= 1, a = a * a)
if (p & 1) ret = ret * a;
return ret;
}
} A, B, X, Y, ans;
int C[N][N], s[N][N], k;
long long l, r;
inline void init(const int& up) {
s[0][0] = 1;
for (register int i = 0; i <= up; ++i) {
C[i][0] = C[i][i] = 1;
for (register int j = 1; j < i; ++j)
C[i][j] = add(C[i - 1][j - 1], C[i - 1][j]);
}
for (register int i = 1; i <= up; ++i)
for (register int j = 1; j <= i; ++j)
s[i][j] = add(s[i - 1][j - 1], mul(s[i - 1][j], i - 1));
A = cp(0, ksm(5, mod - 2)), B = cp(0, mod - ksm(5, mod - 2));
X = cp((mod + 1) >> 1, (mod + 1) >> 1),
Y = cp((mod + 1) >> 1, mod - ((mod + 1) >> 1));
}
inline cp S(cp x, int k) {
if (x.x == 1 && x.y == 0) return x * ((r - l + 1) % mod);
return (x ^ l) * (((x ^ (r - l + 1)) - cp(1, 0)) / (x - cp(1, 0)));
}
inline cp calc(int k) {
cp ret;
for (register int i = 0; i <= k; ++i)
ret = ret +
(S((X ^ i) * (Y ^ (k - i)), i) * ((A ^ i) * (B ^ (k - i))) * C[k][i]);
return ret;
}
int main() {
cin >> k >> l >> r, l += 2, r += 2;
init(k);
cp t;
register int mt = 1;
for (register int i = 0; i <= k; ++i)
t = calc(i) * s[k][i], (k + i)& 1 ? ans = ans - t : ans = ans + t,
Mul(mt, i ? i : 1);
cout << mul(ans.x, ksm(mt, mod - 2));
return 0;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
In mathematics, a subsequence is a sequence that can be derived from another sequence by deleting some elements without changing the order of the remaining elements. For example, the sequence BDF is a subsequence of ABCDEF. A substring of a string is a continuous subsequence of the string. For example, BCD is a substring of ABCDEF.
You are given two strings s1, s2 and another string called virus. Your task is to find the longest common subsequence of s1 and s2, such that it doesn't contain virus as a substring.
Input
The input contains three strings in three separate lines: s1, s2 and virus (1 ≤ |s1|, |s2|, |virus| ≤ 100). Each string consists only of uppercase English letters.
Output
Output the longest common subsequence of s1 and s2 without virus as a substring. If there are multiple answers, any of them will be accepted.
If there is no valid common subsequence, output 0.
Examples
Input
AJKEQSLOBSROFGZ
OVGURWZLWVLUXTH
OZ
Output
ORZ
Input
AA
A
A
Output
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int dp[102][102][102];
int state[102][102][102];
string s1, s2, virus;
int n1, n2, n3;
vector<int> fail;
vector<int> failF() {
vector<int> T(102, -1);
for (int i = 1; i <= virus.length(); i++) {
int pos = T[i - 1];
while (pos != -1 && virus.at(pos) != virus.at(i - 1)) pos = T[pos];
T[i] = pos + 1;
}
return T;
}
int z = 1;
int dpM(int i1, int i2, int i3) {
if (dp[i1][i2][i3] != -1) return dp[i1][i2][i3];
int sol = dpM(i1 + 1, i2, i3);
state[i1][i2][i3] = -1;
int temp = dpM(i1, i2 + 1, i3);
if (temp > sol) {
sol = temp;
state[i1][i2][i3] = -2;
}
if (s1.at(i1) == s2.at(i2)) {
int d = i3;
while (d >= 0 && s1.at(i1) != virus.at(d)) {
d = fail[d];
z++;
}
d++;
temp = 1 + dpM(i1 + 1, i2 + 1, d);
if (temp > sol) {
sol = temp;
state[i1][i2][i3] = d;
}
}
return dp[i1][i2][i3] = sol;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> s1 >> s2 >> virus;
n1 = s1.length();
n2 = s2.length();
n3 = virus.length();
fail = failF();
memset(dp, 0xff, sizeof(dp));
for (int i = 0; i <= n1; i++) {
for (int j = 0; j <= n2; j++) dp[i][j][n3] = -1000000000;
}
for (int i = 0; i <= n1; i++) {
for (int k = 0; k < n3; k++) dp[i][n2][k] = 0;
}
for (int j = 0; j <= n2; j++) {
for (int k = 0; k < n3; k++) dp[n1][j][k] = 0;
}
int ans = dpM(0, 0, 0);
if (ans <= 0)
cout << 0 << '\n';
else {
int i1 = 0, i2 = 0, i3 = 0, c = 0;
while (c < ans) {
switch (state[i1][i2][i3]) {
case -1:
i1++;
break;
case -2:
i2++;
break;
default:
cout << s1.at(i1);
i3 = state[i1][i2][i3];
i1++;
i2++;
c++;
}
}
}
return 0;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
AtCoder Inc. has decided to lock the door of its office with a 3-digit PIN code.
The company has an N-digit lucky number, S. Takahashi, the president, will erase N-3 digits from S and concatenate the remaining 3 digits without changing the order to set the PIN code.
How many different PIN codes can he set this way?
Both the lucky number and the PIN code may begin with a 0.
Constraints
* 4 \leq N \leq 30000
* S is a string of length N consisting of digits.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the number of different PIN codes Takahashi can set.
Examples
Input
4
0224
Output
3
Input
6
123123
Output
17
Input
19
3141592653589793238
Output
329
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
string S;
cin >> N >> S;
int ans = 0;
for (int i = 0; i < 1000; i++) {
string A = S;
string B = to_string(i);
while (B.size() < 3) B = '0' + B;
for (int i = 0; i < 3; i++) {
int j = (int)A.find(B.at(i));
if (j == -1) goto NG;
A = A.substr(j + 1);
}
ans++;
NG:;
}
cout << ans << "\n";
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
There are N persons, conveniently numbered 1 through N. They will take 3y3s Challenge for N-1 seconds.
During the challenge, each person must look at each of the N-1 other persons for 1 seconds, in some order.
If any two persons look at each other during the challenge, the challenge ends in failure.
Find the order in which each person looks at each of the N-1 other persons, to be successful in the challenge.
Constraints
* 2 \leq N \leq 100
Input
The input is given from Standard Input in the following format:
N
Output
If there exists no way to be successful in the challenge, print `-1`.
If there exists a way to be successful in the challenge, print any such way in the following format:
A_{1,1} A_{1,2} ... A_{1, N-1}
A_{2,1} A_{2,2} ... A_{2, N-1}
:
A_{N,1} A_{N,2} ... A_{N, N-1}
where A_{i, j} is the index of the person that the person numbered i looks at during the j-th second.
Judging
The output is considered correct only if all of the following conditions are satisfied:
* 1 \leq A_{i,j} \leq N
* For each i, A_{i,1}, A_{i,2}, ... , A_{i, N-1} are pairwise distinct.
* Let X = A_{i, j}, then A_{X, j} \neq i always holds.
Examples
Input
7
Output
2 3 4 5 6 7
5 3 1 6 4 7
2 7 4 1 5 6
2 1 7 5 3 6
1 4 3 7 6 2
2 5 7 3 4 1
2 6 1 4 5 3
Input
2
Output
-1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct Initializer {
Initializer() {
cin.tie(0);
ios::sync_with_stdio(0);
cout << fixed << setprecision(15);
}
} initializer;
int main() {
int n;
cin >> n;
if (n == 2) {
cout << -1 << endl;
} else if (n % 2 == 0) {
vector<vector<int>> res(n);
for (int i = 0; i < n; ++i) {
for (int j = 2; j < n; ++j) {
if (j == n / 2) continue;
res[i].emplace_back((i + j) % n + 1);
}
}
for (int i = 0; i < n; ++i) {
if (i < n / 2) res[i].emplace_back((i + 1) % n + 1);
else res[i].emplace_back((i + n / 2) % n + 1);
}
for (int i = 0; i < n; ++i) {
if (i >= n / 2) res[i].emplace_back((i + 1) % n + 1);
else res[i].emplace_back((i + n / 2) % n + 1);
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n - 1; ++j) cout << res[i][j] << (j < n - 2 ? " " : "\n");
}
} else {
for (int i = 0; i < n; ++i) {
for (int j = 1; j < n; ++j) {
cout << (i + j) % n + 1 << (j < n - 1 ? " " : "\n");
}
}
}
}
``` |
### Prompt
Create a solution in cpp for the following problem:
There is a grid of square cells with H horizontal rows and W vertical columns. The cell at the i-th row and the j-th column will be denoted as Cell (i, j).
In Cell (i, j), a_{ij} coins are placed.
You can perform the following operation any number of times:
Operation: Choose a cell that was not chosen before and contains one or more coins, then move one of those coins to a vertically or horizontally adjacent cell.
Maximize the number of cells containing an even number of coins.
Constraints
* All values in input are integers.
* 1 \leq H, W \leq 500
* 0 \leq a_{ij} \leq 9
Input
Input is given from Standard Input in the following format:
H W
a_{11} a_{12} ... a_{1W}
a_{21} a_{22} ... a_{2W}
:
a_{H1} a_{H2} ... a_{HW}
Output
Print a sequence of operations that maximizes the number of cells containing an even number of coins, in the following format:
N
y_1 x_1 y_1' x_1'
y_2 x_2 y_2' x_2'
:
y_N x_N y_N' x_N'
That is, in the first line, print an integer N between 0 and H \times W (inclusive), representing the number of operations.
In the (i+1)-th line (1 \leq i \leq N), print four integers y_i, x_i, y_i' and x_i' (1 \leq y_i, y_i' \leq H and 1 \leq x_i, x_i' \leq W), representing the i-th operation. These four integers represents the operation of moving one of the coins placed in Cell (y_i, x_i) to a vertically or horizontally adjacent cell, (y_i', x_i').
Note that if the specified operation violates the specification in the problem statement or the output format is invalid, it will result in Wrong Answer.
Examples
Input
2 3
1 2 3
0 1 1
Output
3
2 2 2 3
1 1 1 2
1 3 1 2
Input
3 2
1 0
2 1
1 0
Output
3
1 1 1 2
1 2 2 2
3 1 3 2
Input
1 5
9 9 9 9 9
Output
2
1 1 1 2
1 3 1 4
### Response
```cpp
#include <iostream>
using namespace std;
int main(){
int h,w;
cin >> h >> w;
int a[h][w];
for(int i=0;i<h;i++) for(int j=0;j<w;j++) cin >> a[i][j];
int ans=0;
int sum=h*w;
int y[sum],x[sum],yy[sum],xx[sum];
for(int i=0;i<h;i++){
for(int j=0;j<w-1;j++){
if(a[i][j]%2==1){
y[ans]=i,x[ans]=j,yy[ans]=i,xx[ans]=j+1;
a[i][j]--; a[i][j+1]++;
ans++;
}
}
}
for(int i=0;i<h-1;i++){
if(a[i][w-1]%2==1){
y[ans]=i,x[ans]=w-1,yy[ans]=i+1,xx[ans]=w-1;
a[i][w-1]--; a[i+1][w-1]++;
ans++;
}
}
cout << ans << endl;
for(int i=0;i<ans;i++){
cout << y[i]+1 << ' ' << x[i]+1 << ' ' << yy[i]+1 << ' ' << xx[i]+1 << endl;
}
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
A trick of fate caused Hatsumi and Taku to come to know each other. To keep the encounter in memory, they decided to calculate the difference between their ages. But the difference in ages varies depending on the day it is calculated. While trying again and again, they came to notice that the difference of their ages will hit a maximum value even though the months move on forever.
Given the birthdays for the two, make a program to report the maximum difference between their ages. The age increases by one at the moment the birthday begins. If the birthday coincides with the 29th of February in a leap year, the age increases at the moment the 1st of March arrives in non-leap years.
Input
The input is given in the following format.
y_1 m_1 d_1
y_2 m_2 d_2
The first and second lines provide Hatsumi’s and Taku’s birthdays respectively in year y_i (1 ≤ y_i ≤ 3000), month m_i (1 ≤ m_i ≤ 12), and day d_i (1 ≤ d_i ≤ Dmax) format. Where Dmax is given as follows:
* 28 when February in a non-leap year
* 29 when February in a leap-year
* 30 in April, June, September, and November
* 31 otherwise.
It is a leap year if the year represented as a four-digit number is divisible by 4. Note, however, that it is a non-leap year if divisible by 100, and a leap year if divisible by 400.
Output
Output the maximum difference between their ages.
Examples
Input
1999 9 9
2001 11 3
Output
3
Input
2008 2 29
2015 3 1
Output
8
### Response
```cpp
#include <iostream>
#include <algorithm>
using namespace std;
int main() {
pair< int, pair<int,int> > p1, p2;
cin >> p1.first >> p1.second.first >> p1.second.second;
cin >> p2.first >> p2.second.first >> p2.second.second;
if ( p1 > p2 ) swap( p1, p2 );
if ( p1.second < p2.second )
cout << p2.first - p1.first + 1 << endl;
else cout << p2.first - p1.first << endl;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
DZY has a sequence a, consisting of n integers.
We'll call a sequence ai, ai + 1, ..., aj (1 ≤ i ≤ j ≤ n) a subsegment of the sequence a. The value (j - i + 1) denotes the length of the subsegment.
Your task is to find the longest subsegment of a, such that it is possible to change at most one number (change one number to any integer you want) from the subsegment to make the subsegment strictly increasing.
You only need to output the length of the subsegment you find.
Input
The first line contains integer n (1 ≤ n ≤ 105). The next line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109).
Output
In a single line print the answer to the problem — the maximum length of the required subsegment.
Examples
Input
6
7 2 3 1 5 6
Output
5
Note
You can choose subsegment a2, a3, a4, a5, a6 and change its 3rd element (that is a4) to 4.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 5;
int n, ans = 1;
int a[MAX];
int dp[MAX][2];
int main() {
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
dp[0][0] = dp[0][1] = 1;
for (int i = 1; i < n; ++i) {
if (a[i] > a[i - 1])
dp[i][0] = dp[i - 1][0] + 1;
else
dp[i][0] = 1;
int l = i - dp[i][0];
if (l <= 0) dp[i][1] = i + 1;
if (dp[i][0] + 1 < i + 1) dp[i][1] = max(dp[i][1], dp[i][0] + 1);
if (l > 0 && a[l + 1] > a[l - 1] + 1)
dp[i][1] = max(dp[i][1], dp[i][0] + 1 + dp[l - 1][0]);
if (l + 2 <= i && a[l + 2] > a[l] + 1)
dp[i][1] = max(dp[i][1], dp[i][0] + dp[l][0]);
if (dp[i][0] == 1) dp[i][1] = max(dp[i][1], dp[i - 1][0] + 1);
ans = max(ans, dp[i][0]);
ans = max(ans, dp[i][1]);
}
cout << ans;
return 0;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
The Little Girl loves problems on games very much. Here's one of them.
Two players have got a string s, consisting of lowercase English letters. They play a game that is described by the following rules:
* The players move in turns; In one move the player can remove an arbitrary letter from string s.
* If the player before his turn can reorder the letters in string s so as to get a palindrome, this player wins. A palindrome is a string that reads the same both ways (from left to right, and vice versa). For example, string "abba" is a palindrome and string "abc" isn't.
Determine which player will win, provided that both sides play optimally well — the one who moves first or the one who moves second.
Input
The input contains a single line, containing string s (1 ≤ |s| ≤ 103). String s consists of lowercase English letters.
Output
In a single line print word "First" if the first player wins (provided that both players play optimally well). Otherwise, print word "Second". Print the words without the quotes.
Examples
Input
aba
Output
First
Input
abca
Output
Second
### Response
```cpp
#include <bits/stdc++.h>
char alp[26] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',
'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r',
's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
int char_to_int(char c) {
for (int i = 0; i < 26; i++)
if (c == alp[i]) return i;
}
int main() {
char *str = (char *)malloc(sizeof(char) * 1001);
int *trace = (int *)calloc(1001, sizeof(int));
scanf("%s", str);
int n = strlen(str), m;
for (int i = 0; i < n; i++) {
m = char_to_int(*(str + i));
*(trace + m) = *(trace + m) + 1;
}
int odds = 0;
for (int i = 0; i < 26; i++) {
if (*(trace + i) % 2 != 0) odds++;
}
if (odds == 0 || odds == 1)
printf("First");
else {
if (odds % 2 != 0) printf("First");
if (odds % 2 == 0) printf("Second");
}
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
Mr. Scrooge, a very busy man, decided to count the time he wastes on all sorts of useless stuff to evaluate the lost profit. He has already counted the time he wastes sleeping and eating. And now Mr. Scrooge wants to count the time he has wasted signing papers.
Mr. Scrooge's signature can be represented as a polyline A1A2... An. Scrooge signs like that: first it places a pen at the point A1, then draws a segment from point A1 to point A2, then he draws a segment from point A2 to point A3 and so on to point An, where he stops signing and takes the pen off the paper. At that the resulting line can intersect with itself and partially repeat itself but Scrooge pays no attention to it and never changes his signing style. As Scrooge makes the signature, he never takes the pen off the paper and his writing speed is constant — 50 millimeters per second.
Scrooge signed exactly k papers throughout his life and all those signatures look the same.
Find the total time Scrooge wasted signing the papers.
Input
The first line contains two integers n and k (2 ≤ n ≤ 100, 1 ≤ k ≤ 1000). Each of the following n lines contains the coordinates of the polyline's endpoints. The i-th one contains coordinates of the point Ai — integers xi and yi, separated by a space.
All points Ai are different. The absolute value of all coordinates does not exceed 20. The coordinates are measured in millimeters.
Output
Print one real number — the total time Scrooges wastes on signing the papers in seconds. The absolute or relative error should not exceed 10 - 6.
Examples
Input
2 1
0 0
10 0
Output
0.200000000
Input
5 10
3 1
-5 6
-2 -1
3 2
10 0
Output
6.032163204
Input
6 10
5 0
4 0
6 0
3 0
7 0
2 0
Output
3.000000000
### Response
```cpp
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int N = 1e2 + 5, M = 100 + 5, OO = 0x3f3f3f3f, mod = 1e9 + 7, base = 131,
mod2 = 1000136437, mod3 = 998244353;
const double EPS = 1e-9;
int n, k;
complex<double> tmp;
long double ans;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
complex<double> p(a, b);
if (i) {
ans += hypot(p.real() - tmp.real(), p.imag() - tmp.imag());
}
tmp = p;
}
cout << fixed << setprecision(6) << ans * (k * 1.0 / 50.0);
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
Two soldiers are playing a game. At the beginning first of them chooses a positive integer n and gives it to the second soldier. Then the second one tries to make maximum possible number of rounds. Each round consists of choosing a positive integer x > 1, such that n is divisible by x and replacing n with n / x. When n becomes equal to 1 and there is no more possible valid moves the game is over and the score of the second soldier is equal to the number of rounds he performed.
To make the game more interesting, first soldier chooses n of form a! / b! for some positive integer a and b (a ≥ b). Here by k! we denote the factorial of k that is defined as a product of all positive integers not large than k.
What is the maximum possible score of the second soldier?
Input
First line of input consists of single integer t (1 ≤ t ≤ 1 000 000) denoting number of games soldiers play.
Then follow t lines, each contains pair of integers a and b (1 ≤ b ≤ a ≤ 5 000 000) defining the value of n for a game.
Output
For each game output a maximum score that the second soldier can get.
Examples
Input
2
3 1
6 3
Output
2
5
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long primes[5000009] = {0, 0}, arr[5000009] = {0};
int main() {
for (long long f = 2; f <= 5000003; f++) {
if (!primes[f]) {
for (long long f1 = f; f1 <= 5000003; f1 += f) {
long long temp = f1;
while (temp % f == 0) {
primes[f1]++;
temp /= f;
}
}
}
}
for (int f = 1; f <= 5000003; f++) arr[f] = primes[f] + arr[f - 1];
long long t, a, b;
scanf("%I64d", &t);
while (t--) {
scanf("%I64d %I64d", &a, &b);
printf("%I64d\n", arr[a] - arr[b]);
}
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
Capitalization is writing a word with its first letter as a capital letter. Your task is to capitalize the given word.
Note, that during capitalization all the letters except the first one remains unchanged.
Input
A single line contains a non-empty word. This word consists of lowercase and uppercase English letters. The length of the word will not exceed 103.
Output
Output the given word after capitalization.
Examples
Input
ApPLe
Output
ApPLe
Input
konjac
Output
Konjac
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
char *a;
int n = 10000;
a = new char[n];
cin >> a;
a[0] = toupper(a[0]);
cout << a;
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
The map of Berland is a rectangle of the size n × m, which consists of cells of size 1 × 1. Each cell is either land or water. The map is surrounded by the ocean.
Lakes are the maximal regions of water cells, connected by sides, which are not connected with the ocean. Formally, lake is a set of water cells, such that it's possible to get from any cell of the set to any other without leaving the set and moving only to cells adjacent by the side, none of them is located on the border of the rectangle, and it's impossible to add one more water cell to the set such that it will be connected with any other cell.
You task is to fill up with the earth the minimum number of water cells so that there will be exactly k lakes in Berland. Note that the initial number of lakes on the map is not less than k.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 0 ≤ k ≤ 50) — the sizes of the map and the number of lakes which should be left on the map.
The next n lines contain m characters each — the description of the map. Each of the characters is either '.' (it means that the corresponding cell is water) or '*' (it means that the corresponding cell is land).
It is guaranteed that the map contain at least k lakes.
Output
In the first line print the minimum number of cells which should be transformed from water to land.
In the next n lines print m symbols — the map after the changes. The format must strictly follow the format of the map in the input data (there is no need to print the size of the map). If there are several answers, print any of them.
It is guaranteed that the answer exists on the given data.
Examples
Input
5 4 1
****
*..*
****
**.*
..**
Output
1
****
*..*
****
****
..**
Input
3 3 0
***
*.*
***
Output
1
***
***
***
Note
In the first example there are only two lakes — the first consists of the cells (2, 2) and (2, 3), the second consists of the cell (4, 3). It is profitable to cover the second lake because it is smaller. Pay attention that the area of water in the lower left corner is not a lake because this area share a border with the ocean.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1}, visited[55][55] = {}, kk, ans,
cnt;
vector<pair<int, pair<int, int>>> del;
bool r = true;
int n, m, k;
char dat[55][55];
int dfs(int a, int b, bool c) {
if (a == 0 or b == 0 or a == n - 1 or b == m - 1) {
r = false;
return 0;
}
if (visited[a][b]) return 0;
visited[a][b] = 1;
if (dat[a][b] == '*') return 0;
for (int(i) = 0; (i) < (4); ++(i)) {
if (dat[a + dx[i]][b + dy[i]] == '.' &&
visited[a + dx[i]][b + dy[i]] == 0) {
dfs(a + dx[i], b + dy[i], c);
}
}
if (c) dat[a][b] = '*';
cnt++;
if (!r) cnt = 0;
return r;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> m >> k;
for (int(i) = 0; (i) < (n); ++(i)) {
for (int(j) = 0; (j) < (m); ++(j)) {
cin >> dat[i][j];
}
}
for (int(i) = 0; (i) < (n); ++(i)) {
for (int(j) = 0; (j) < (m); ++(j)) {
cnt = 0;
r = true;
dfs(i, j, false);
if (r and cnt > 0) {
del.push_back(make_pair(cnt, make_pair(i, j)));
kk++;
}
}
}
sort(del.begin(), del.end());
for (int(i) = 0; (i) < (55); ++(i))
for (int(j) = 0; (j) < (55); ++(j)) visited[i][j] = 0;
for (int(i) = 0; (i) < (kk - k); ++(i)) {
int f = del.front().first;
int sf = del.front().second.first;
int ss = del.front().second.second;
del.erase(del.begin());
ans += f;
dfs(sf, ss, true);
}
cout << ans << endl;
for (int(i) = 0; (i) < (n); ++(i)) {
for (int(j) = 0; (j) < (m); ++(j)) {
cout << dat[i][j];
}
cout << endl;
}
return 0;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
Alice and Bob love playing one-dimensional battle ships. They play on the field in the form of a line consisting of n square cells (that is, on a 1 × n table).
At the beginning of the game Alice puts k ships on the field without telling their positions to Bob. Each ship looks as a 1 × a rectangle (that is, it occupies a sequence of a consecutive squares of the field). The ships cannot intersect and even touch each other.
After that Bob makes a sequence of "shots". He names cells of the field and Alice either says that the cell is empty ("miss"), or that the cell belongs to some ship ("hit").
But here's the problem! Alice like to cheat. May be that is why she responds to each Bob's move with a "miss".
Help Bob catch Alice cheating — find Bob's first move, such that after it you can be sure that Alice cheated.
Input
The first line of the input contains three integers: n, k and a (1 ≤ n, k, a ≤ 2·105) — the size of the field, the number of the ships and the size of each ship. It is guaranteed that the n, k and a are such that you can put k ships of size a on the field, so that no two ships intersect or touch each other.
The second line contains integer m (1 ≤ m ≤ n) — the number of Bob's moves.
The third line contains m distinct integers x1, x2, ..., xm, where xi is the number of the cell where Bob made the i-th shot. The cells are numbered from left to right from 1 to n.
Output
Print a single integer — the number of such Bob's first move, after which you can be sure that Alice lied. Bob's moves are numbered from 1 to m in the order the were made. If the sought move doesn't exist, then print "-1".
Examples
Input
11 3 3
5
4 8 6 1 11
Output
3
Input
5 1 3
2
1 5
Output
-1
Input
5 1 3
1
3
Output
1
### Response
```cpp
#include <bits/stdc++.h>
const int MOD = 1000000007;
const int MAX = 200005;
int arr[MAX];
using namespace std;
int main() {
int n, k, a;
scanf("%d %d %d", &n, &k, &a);
int m;
scanf("%d", &m);
for (int i = 0; i < m; i++) {
scanf("%d", &arr[i]);
};
int ct = (n + 1) / (a + 1);
set<pair<int, int> > s;
s.insert(make_pair(n, 1));
set<pair<int, int> >::iterator it;
for (int i = 0; i < m; i++) {
int q = arr[i];
it = s.lower_bound(make_pair(q, 1));
pair<int, int> ele = *it;
if (ele.first == ele.second) {
if (a == 1) {
ct--;
}
s.erase(ele);
if (ct < k) {
cout << i + 1 << endl;
return 0;
}
continue;
}
ct -= (ele.first - ele.second + 1 + 1) / (a + 1);
ct += (q - ele.second + 1) / (a + 1) + (ele.first - q + 1) / (a + 1);
s.erase(ele);
if (ct < k) {
cout << i + 1 << endl;
return 0;
}
s.insert(make_pair(ele.first, q + 1));
s.insert(make_pair(q - 1, ele.second));
}
cout << -1 << 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.