text
stringlengths 424
69.5k
|
|---|
### Prompt
Please create a solution in cpp to the following problem:
Ostap is preparing to play chess again and this time he is about to prepare. Thus, he was closely monitoring one recent chess tournament. There were m players participating and each pair of players played exactly one game. The victory gives 2 points, draw — 1 points, lose — 0 points.
Ostap is lazy, so he never tries to remember the outcome of each game. Instead, he computes the total number of points earned by each of the players (the sum of his points in all games which he took part in), sort these value in non-ascending order and then remembers first n integers in this list.
Now the Great Strategist Ostap wonders whether he remembers everything correct. He considers that he is correct if there exists at least one tournament results table such that it will produce the given integers. That means, if we count the sum of points for each player, sort them and take first n elements, the result will coincide with what Ostap remembers. Can you check if such table exists?
Input
The first line of the input contains two integers m and n (1 ≤ n ≤ m ≤ 3000) — the number of participants of the tournament and the number of top results Ostap remembers.
The second line contains n integers, provided in non-ascending order — the number of points earned by top participants as Ostap remembers them. It's guaranteed that this integers are non-negative and do not exceed 2·m.
Output
If there is no tournament such that Ostap can obtain the given set of integers using the procedure described in the statement, then print "no" in the only line of the output. Otherwise, the first line of the output should contain the word "yes". Next m lines should provide the description of any valid tournament. Each of these lines must contain m characters 'X', 'W', 'D' and 'L'. Character 'X' should always be located on the main diagonal (and only there), that is on the i-th position of the i-th string. Character 'W' on the j-th position of the i-th string means that the i-th player won the game against the j-th. In the same way character 'L' means loose and 'D' means draw.
The table you print must be consistent and the points earned by best n participants should match the memory of Ostap. If there are many possible answers, print any of them.
Examples
Input
5 5
8 6 4 2 0
Output
yes
XWWWW
LXWWW
LLXWW
LLLXW
LLLLX
Input
5 1
9
Output
no
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int score[3005];
vector<int> hasScore[6005];
char ans[3005][3005];
int main() {
int m, n;
scanf("%d%d", &m, &n);
int scoreLeft = (m * (m - 1));
for (int i = (0); i < int(n); ++i) {
scanf("%d", score + i);
hasScore[score[i]].push_back(i);
scoreLeft -= score[i];
}
if (n == m) {
if (scoreLeft) {
puts("no");
return 0;
}
} else {
int average = scoreLeft / (m - n);
int numLarger = scoreLeft % (m - n);
int largestNew = average + (numLarger > 0);
if (largestNew > score[n - 1]) {
puts("no");
return 0;
}
int j = n;
for (int i = (0); i < int(numLarger); ++i)
hasScore[average + 1].push_back(j++);
while (j < m) hasScore[average].push_back(j++);
}
for (int i = (0); i < int(m); ++i) {
ans[i][i] = 'X';
ans[i][m] = 0;
for (int j = 6000; j >= 0; --j) {
if (hasScore[j].empty()) continue;
int cur = hasScore[j].back();
hasScore[j].pop_back();
int opponents = m - i - 1;
int numWins = j - opponents;
if (numWins < 0 || numWins > opponents) {
puts("no");
return 0;
}
for (int k = (0); k < int(j + 1); ++k) {
vector<int> newV;
while (!hasScore[k].empty()) {
int b = hasScore[k].back();
hasScore[k].pop_back();
if (numWins) {
ans[cur][b] = 'W';
ans[b][cur] = 'L';
newV.push_back(b);
--numWins;
} else {
ans[cur][b] = 'D';
ans[b][cur] = 'D';
hasScore[k - 1].push_back(b);
}
}
hasScore[k] = newV;
}
break;
}
}
printf("yes\n");
for (int i = (0); i < int(m); ++i) printf("%s\n", ans[i]);
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
Valera loves his garden, where n fruit trees grow.
This year he will enjoy a great harvest! On the i-th tree bi fruit grow, they will ripen on a day number ai. Unfortunately, the fruit on the tree get withered, so they can only be collected on day ai and day ai + 1 (all fruits that are not collected in these two days, become unfit to eat).
Valera is not very fast, but there are some positive points. Valera is ready to work every day. In one day, Valera can collect no more than v fruits. The fruits may be either from the same tree, or from different ones. What is the maximum amount of fruit Valera can collect for all time, if he operates optimally well?
Input
The first line contains two space-separated integers n and v (1 ≤ n, v ≤ 3000) — the number of fruit trees in the garden and the number of fruits that Valera can collect in a day.
Next n lines contain the description of trees in the garden. The i-th line contains two space-separated integers ai and bi (1 ≤ ai, bi ≤ 3000) — the day the fruits ripen on the i-th tree and the number of fruits on the i-th tree.
Output
Print a single integer — the maximum number of fruit that Valera can collect.
Examples
Input
2 3
1 5
2 3
Output
8
Input
5 10
3 20
2 20
1 20
4 20
5 20
Output
60
Note
In the first sample, in order to obtain the optimal answer, you should act as follows.
* On the first day collect 3 fruits from the 1-st tree.
* On the second day collect 1 fruit from the 2-nd tree and 2 fruits from the 1-st tree.
* On the third day collect the remaining fruits from the 2-nd tree.
In the second sample, you can only collect 60 fruits, the remaining fruit will simply wither.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long n, v, b1, b2, a[5000], os, s, f;
int main() {
cin >> n >> v;
for (long long i = 0; i < n; i++) {
cin >> b1 >> b2;
a[b1] += b2;
}
for (long long i = 1; i < 3005; i++) {
if (a[i] > 0) {
if (a[i] + os <= v) {
s += a[i] + os;
os = 0;
} else {
if (os >= v) {
s += v;
os = a[i];
} else {
s += v;
os = os + a[i] - v;
}
}
} else if (os > 0) {
s += min(os, v);
os = 0;
}
}
cout << s << endl;
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
Vasya came up with his own weather forecasting method. He knows the information about the average air temperature for each of the last n days. Assume that the average air temperature for each day is integral.
Vasya believes that if the average temperatures over the last n days form an arithmetic progression, where the first term equals to the average temperature on the first day, the second term equals to the average temperature on the second day and so on, then the average temperature of the next (n + 1)-th day will be equal to the next term of the arithmetic progression. Otherwise, according to Vasya's method, the temperature of the (n + 1)-th day will be equal to the temperature of the n-th day.
Your task is to help Vasya predict the average temperature for tomorrow, i. e. for the (n + 1)-th day.
Input
The first line contains a single integer n (2 ≤ n ≤ 100) — the number of days for which the average air temperature is known.
The second line contains a sequence of integers t1, t2, ..., tn ( - 1000 ≤ ti ≤ 1000) — where ti is the average temperature in the i-th day.
Output
Print the average air temperature in the (n + 1)-th day, which Vasya predicts according to his method. Note that the absolute value of the predicted temperature can exceed 1000.
Examples
Input
5
10 5 0 -5 -10
Output
-15
Input
4
1 1 1 1
Output
1
Input
3
5 1 -5
Output
-5
Input
2
900 1000
Output
1100
Note
In the first example the sequence of the average temperatures is an arithmetic progression where the first term is 10 and each following terms decreases by 5. So the predicted average temperature for the sixth day is - 10 - 5 = - 15.
In the second example the sequence of the average temperatures is an arithmetic progression where the first term is 1 and each following terms equals to the previous one. So the predicted average temperature in the fifth day is 1.
In the third example the average temperatures do not form an arithmetic progression, so the average temperature of the fourth day equals to the temperature of the third day and equals to - 5.
In the fourth example the sequence of the average temperatures is an arithmetic progression where the first term is 900 and each the following terms increase by 100. So predicted average temperature in the third day is 1000 + 100 = 1100.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j, abs_value;
cin >> n;
int a[n + 2];
for (i = 0; i < n; i++) {
cin >> a[i];
}
abs_value = abs(a[1] - a[0]);
for (i = 1; i < n; i++) {
if (abs(a[i] - a[i - 1]) != abs_value) {
cout << a[n - 1] << endl;
return 0;
}
}
if (a[n - 1] < a[n - 2]) {
cout << a[n - 1] - abs_value << endl;
} else {
cout << a[n - 1] + abs_value << endl;
}
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
Smart Beaver decided to be not only smart, but also a healthy beaver! And so he began to attend physical education classes at school X. In this school, physical education has a very creative teacher. One of his favorite warm-up exercises is throwing balls. Students line up. Each one gets a single ball in the beginning. The balls are numbered from 1 to n (by the demand of the inventory commission).
<image> Figure 1. The initial position for n = 5.
After receiving the balls the students perform the warm-up exercise. The exercise takes place in a few throws. For each throw the teacher chooses any two arbitrary different students who will participate in it. The selected students throw their balls to each other. Thus, after each throw the students remain in their positions, and the two balls are swapped.
<image> Figure 2. The example of a throw.
In this case there was a throw between the students, who were holding the 2-nd and the 4-th balls. Since the warm-up has many exercises, each of them can only continue for little time. Therefore, for each student we know the maximum number of throws he can participate in. For this lessons maximum number of throws will be 1 or 2.
Note that after all phases of the considered exercise any ball can end up with any student. Smart Beaver decided to formalize it and introduced the concept of the "ball order". The ball order is a sequence of n numbers that correspond to the order of balls in the line. The first number will match the number of the ball of the first from the left student in the line, the second number will match the ball of the second student, and so on. For example, in figure 2 the order of the balls was (1, 2, 3, 4, 5), and after the throw it was (1, 4, 3, 2, 5). Smart beaver knows the number of students and for each student he knows the maximum number of throws in which he can participate. And now he is wondering: what is the number of distinct ways of ball orders by the end of the exercise.
Input
The first line contains a single number n — the number of students in the line and the number of balls. The next line contains exactly n space-separated integers. Each number corresponds to a student in the line (the i-th number corresponds to the i-th from the left student in the line) and shows the number of throws he can participate in.
The input limits for scoring 30 points are (subproblem D1):
* 1 ≤ n ≤ 10.
The input limits for scoring 70 points are (subproblems D1+D2):
* 1 ≤ n ≤ 500.
The input limits for scoring 100 points are (subproblems D1+D2+D3):
* 1 ≤ n ≤ 1000000.
Output
The output should contain a single integer — the number of variants of ball orders after the warm up exercise is complete. As the number can be rather large, print it modulo 1000000007 (109 + 7).
Examples
Input
5
1 2 2 1 2
Output
120
Input
8
1 2 2 1 2 1 1 2
Output
16800
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &x) {
int f = 0, c = getchar();
x = 0;
while (!isdigit(c)) f |= c == 45, c = getchar();
while (isdigit(c)) x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
if (f) x = -x;
}
template <typename T, typename... Args>
inline void read(T &x, Args &...args) {
read(x);
read(args...);
}
namespace run {
const int maxn = 1e6 + 10;
const long long mod = 1e9 + 7;
long long f[maxn];
long long ans;
int n, m;
inline int main() {
read(n);
for (register int i = 1, x; i <= n; ++i) read(x), m += x == 1;
f[0] = f[1] = 1ll;
for (register int i = 2; i <= m; ++i)
f[i] = (f[i - 1] + f[i - 2] * (i - 1) % mod) % mod;
ans = f[m];
for (register int i = m + 1; i <= n; ++i) ans = ans * i % mod;
printf("%lld\n", ans);
return 0;
}
} // namespace run
int main() { return run ::main(); }
``` |
### Prompt
Please create a solution in cpp to the following problem:
You are given integers N and K. Find the number of triples (a,b,c) of positive integers not greater than N such that a+b,b+c and c+a are all multiples of K. The order of a,b,c does matter, and some of them can be the same.
Constraints
* 1 \leq N,K \leq 2\times 10^5
* N and K are integers.
Input
Input is given from Standard Input in the following format:
N K
Output
Print the number of triples (a,b,c) of positive integers not greater than N such that a+b,b+c and c+a are all multiples of K.
Examples
Input
3 2
Output
9
Input
5 3
Output
1
Input
31415 9265
Output
27
Input
35897 932
Output
114191
### Response
```cpp
#include<bits/stdc++.h>
#define int long long
using namespace std;
int n,k;
signed main()
{
scanf("%lld%lld",&n,&k);
if(k%2==1)
{
int a=n/k;
printf("%lld\n",a*a*a);
}
else
{
int a=n/(k/2);
a=(a+1)/2;
printf("%lld\n",a*a*a+(n/k)*(n/k)*(n/k));
}
return 0;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
There are several days left before the fiftieth birthday of a famous Berland's writer Berlbury. In this connection the local library decided to make an exposition of the works of this famous science-fiction writer. It was decided as well that it is necessary to include into the exposition only those books that were published during a particular time period. It is obvious that if the books differ much in size, the visitors will not like it. That was why the organizers came to the opinion, that the difference between the highest and the lowest books in the exposition should be not more than k millimeters.
The library has n volumes of books by Berlbury, arranged in chronological order of their appearance. The height of each book in millimeters is know, it is hi. As Berlbury is highly respected in the city, the organizers want to include into the exposition as many books as possible, and to find out what periods of his creative work they will manage to cover. You are asked to help the organizers cope with this hard task.
Input
The first line of the input data contains two integer numbers separated by a space n (1 ≤ n ≤ 105) and k (0 ≤ k ≤ 106) — the amount of books by Berlbury in the library, and the maximum allowed height difference between the lowest and the highest books. The second line contains n integer numbers separated by a space. Each number hi (1 ≤ hi ≤ 106) is the height of the i-th book in millimeters.
Output
In the first line of the output data print two numbers a and b (separate them by a space), where a is the maximum amount of books the organizers can include into the exposition, and b — the amount of the time periods, during which Berlbury published a books, and the height difference between the lowest and the highest among these books is not more than k milllimeters.
In each of the following b lines print two integer numbers separated by a space — indexes of the first and the last volumes from each of the required time periods of Berlbury's creative work.
Examples
Input
3 3
14 12 10
Output
2 2
1 2
2 3
Input
2 0
10 10
Output
2 1
1 2
Input
4 5
8 19 10 13
Output
2 1
3 4
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, k;
vector<int> h;
map<int, int> M;
map<int, int> N;
vector<int> x, y;
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> k;
h.resize(n);
for (int i = 0; i < n; ++i) cin >> h[i];
int il = 0;
int ir = 1;
int mi;
int ma;
int a = 1;
M[h[0]] = 1;
while (ir < n) {
map<int, int>::iterator it1 = M.begin();
map<int, int>::iterator it2 = M.end();
--it2;
mi = it1->first;
ma = it2->first;
if (ma - mi <= k) {
++M[h[ir]];
++ir;
} else {
++M[h[ir]];
++ir;
--M[h[il]];
if (M[h[il]] == 0) M.erase(h[il]);
++il;
}
it1 = M.begin();
it2 = M.end();
--it2;
mi = it1->first;
ma = it2->first;
if (ma - mi <= k) a = max(a, ir - il);
}
for (int i = 0; i < a; ++i) ++N[h[i]];
map<int, int>::iterator it1 = N.begin();
map<int, int>::iterator it2 = N.end();
--it2;
mi = it1->first;
ma = it2->first;
if (ma - mi <= k) {
x.push_back(1);
y.push_back(a);
}
for (int i = a; i < n; ++i) {
++N[h[i]];
--N[h[i - a]];
if (N[h[i - a]] == 0) N.erase(h[i - a]);
it1 = N.begin();
it2 = N.end();
--it2;
mi = it1->first;
ma = it2->first;
if (ma - mi <= k) {
x.push_back(i - a + 2);
y.push_back(i + 1);
}
}
cout << a << " " << x.size() << endl;
for (int i = 0; i < x.size(); ++i) cout << x[i] << ' ' << y[i] << endl;
return 0;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
You are given an array a consisting of n integer numbers.
You have to color this array in k colors in such a way that:
* Each element of the array should be colored in some color;
* For each i from 1 to k there should be at least one element colored in the i-th color in the array;
* For each i from 1 to k all elements colored in the i-th color should be distinct.
Obviously, such coloring might be impossible. In this case, print "NO". Otherwise print "YES" and any coloring (i.e. numbers c_1, c_2, ... c_n, where 1 ≤ c_i ≤ k and c_i is the color of the i-th element of the given array) satisfying the conditions above. If there are multiple answers, you can print any.
Input
The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 5000) — the length of the array a and the number of colors, respectively.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 5000) — elements of the array a.
Output
If there is no answer, print "NO". Otherwise print "YES" and any coloring (i.e. numbers c_1, c_2, ... c_n, where 1 ≤ c_i ≤ k and c_i is the color of the i-th element of the given array) satisfying the conditions described in the problem statement. If there are multiple answers, you can print any.
Examples
Input
4 2
1 2 2 3
Output
YES
1 1 2 2
Input
5 2
3 2 1 2 3
Output
YES
2 1 1 2 1
Input
5 2
2 1 1 2 1
Output
NO
Note
In the first example the answer 2~ 1~ 2~ 1 is also acceptable.
In the second example the answer 1~ 1~ 1~ 2~ 2 is also acceptable.
There exist other acceptable answers for both examples.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, k;
cin >> n >> k;
int ar[n];
bool flag2 = 1;
vector<vector<int> > vec(k);
for (int i = 0, x; i < n; i++) {
cin >> x;
bool flag1 = 0;
for (int j = 0; j < k; j++) {
if (vec[j].size() == 0) {
vec[j].push_back(x);
ar[i] = j + 1;
goto marlen;
}
}
for (int j = 0; j < k; j++) {
bool flag = 1;
for (int k = 0; k < vec[j].size(); k++) {
if (vec[j][k] == x) {
flag = 0;
break;
}
}
if (flag) {
vec[j].push_back(x);
ar[i] = j + 1;
flag1 = 1;
break;
}
}
if (!flag1) flag2 = 0;
marlen:;
}
if (!flag2)
cout << "NO";
else {
cout << "YES\n";
for (int i = 0; i < n; i++) cout << ar[i] << ' ';
}
return (0);
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
When Kefa came to the restaurant and sat at a table, the waiter immediately brought him the menu. There were n dishes. Kefa knows that he needs exactly m dishes. But at that, he doesn't want to order the same dish twice to taste as many dishes as possible.
Kefa knows that the i-th dish gives him ai units of satisfaction. But some dishes do not go well together and some dishes go very well together. Kefa set to himself k rules of eating food of the following type — if he eats dish x exactly before dish y (there should be no other dishes between x and y), then his satisfaction level raises by c.
Of course, our parrot wants to get some maximal possible satisfaction from going to the restaurant. Help him in this hard task!
Input
The first line of the input contains three space-separated numbers, n, m and k (1 ≤ m ≤ n ≤ 18, 0 ≤ k ≤ n * (n - 1)) — the number of dishes on the menu, the number of portions Kefa needs to eat to get full and the number of eating rules.
The second line contains n space-separated numbers ai, (0 ≤ ai ≤ 109) — the satisfaction he gets from the i-th dish.
Next k lines contain the rules. The i-th rule is described by the three numbers xi, yi and ci (1 ≤ xi, yi ≤ n, 0 ≤ ci ≤ 109). That means that if you eat dish xi right before dish yi, then the Kefa's satisfaction increases by ci. It is guaranteed that there are no such pairs of indexes i and j (1 ≤ i < j ≤ k), that xi = xj and yi = yj.
Output
In the single line of the output print the maximum satisfaction that Kefa can get from going to the restaurant.
Examples
Input
2 2 1
1 1
2 1 1
Output
3
Input
4 3 2
1 2 3 4
2 1 5
3 4 2
Output
12
Note
In the first sample it is best to first eat the second dish, then the first one. Then we get one unit of satisfaction for each dish and plus one more for the rule.
In the second test the fitting sequences of choice are 4 2 1 or 2 1 4. In both cases we get satisfaction 7 for dishes and also, if we fulfill rule 1, we get an additional satisfaction 5.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long mx = 19;
const long long mx1 = 262150;
long long s[mx];
long long n, m, k;
long long extra[mx][mx];
long long dp[mx][mx1];
long long solve(long long prev, long long bitmask, long long m) {
if (m == 0) return 0;
if (dp[prev][bitmask] != -1) return dp[prev][bitmask];
long long ans = INT_MIN;
for (long long j = 0; j < mx; j++) {
if (bitmask & (1 << j))
ans = max(ans, extra[prev][j + 1] + s[j + 1] +
solve(j + 1, bitmask ^ (1 << j), m - 1));
}
return dp[prev][bitmask] = ans;
}
signed main() {
cin >> n >> m >> k;
for (long long i = 1; i <= n; i++) cin >> s[i];
long long a, b, c;
memset(extra, 0, sizeof(extra));
for (long long i = 0; i < k; i++) {
cin >> a >> b >> c;
extra[a][b] = c;
}
long long bitmask = (1 << n) - 1;
long long prev = 0;
memset(dp, -1, sizeof(dp));
cout << solve(prev, bitmask, m) << "\n";
return 0;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
You must have heard of the two brothers dreaming of ruling the world. With all their previous plans failed, this time they decided to cooperate with each other in order to rule the world.
As you know there are n countries in the world. These countries are connected by n - 1 directed roads. If you don't consider direction of the roads there is a unique path between every pair of countries in the world, passing through each road at most once.
Each of the brothers wants to establish his reign in some country, then it's possible for him to control the countries that can be reached from his country using directed roads.
The brothers can rule the world if there exists at most two countries for brothers to choose (and establish their reign in these countries) so that any other country is under control of at least one of them. In order to make this possible they want to change the direction of minimum number of roads. Your task is to calculate this minimum number of roads.
Input
The first line of input contains an integer n (1 ≤ n ≤ 3000). Each of the next n - 1 lines contains two space-separated integers ai and bi (1 ≤ ai, bi ≤ n; ai ≠ bi) saying there is a road from country ai to country bi.
Consider that countries are numbered from 1 to n. It's guaranteed that if you don't consider direction of the roads there is a unique path between every pair of countries in the world, passing through each road at most once.
Output
In the only line of output print the minimum number of roads that their direction should be changed so that the brothers will be able to rule the world.
Examples
Input
4
2 1
3 1
4 1
Output
1
Input
5
2 1
2 3
4 3
4 5
Output
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 3005, INF = 1e7;
int n, ans, f[N], g[N], A[N], B[N], par[N];
vector<pair<int, int> > ke[N];
void dfs1(int u) {
f[u] = 0;
for (auto v : ke[u])
if (v.first != par[u]) {
par[v.first] = u;
dfs1(v.first);
f[u] += f[v.first] + v.second;
}
}
void dfs2(int u, int mi) {
mi = min(mi, B[u] - A[u]);
ans = min(ans, f[u] + g[u] + A[u] + mi);
for (auto v : ke[u])
if (v.first != par[u]) {
g[v.first] = g[u] + f[u] - f[v.first] - v.second;
A[v.first] = A[u] + 1 - v.second;
B[v.first] = B[u] + v.second;
dfs2(v.first, mi);
}
}
int main() {
ios::sync_with_stdio();
cin.tie(0);
cin >> n;
for (int i = 1, loop = n - 1; i <= loop; ++i) {
int u, v;
cin >> u >> v;
ke[u].push_back(make_pair(v, 0));
ke[v].push_back(make_pair(u, 1));
}
ans = INF;
for (int i = 1, loop = n; i <= loop; ++i) {
par[i] = 0;
dfs1(i);
ans = min(ans, f[i]);
for (auto j : ke[i]) {
g[j.first] = f[i] - f[j.first] - j.second;
A[j.first] = 1 - j.second;
B[j.first] = j.second;
dfs2(j.first, INF);
}
}
cout << ans;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
Om Nom is the main character of a game "Cut the Rope". He is a bright little monster who likes visiting friends living at the other side of the park. However the dark old parks can scare even somebody as fearless as Om Nom, so he asks you to help him.
<image>
The park consists of 2n + 1 - 1 squares connected by roads so that the scheme of the park is a full binary tree of depth n. More formally, the entrance to the park is located at the square 1. The exits out of the park are located at squares 2n, 2n + 1, ..., 2n + 1 - 1 and these exits lead straight to the Om Nom friends' houses. From each square i (2 ≤ i < 2n + 1) there is a road to the square <image>. Thus, it is possible to go from the park entrance to each of the exits by walking along exactly n roads.
<image> To light the path roads in the evening, the park keeper installed street lights along each road. The road that leads from square i to square <image> has ai lights.
Om Nom loves counting lights on the way to his friend. Om Nom is afraid of spiders who live in the park, so he doesn't like to walk along roads that are not enough lit. What he wants is that the way to any of his friends should have in total the same number of lights. That will make him feel safe.
He asked you to help him install additional lights. Determine what minimum number of lights it is needed to additionally place on the park roads so that a path from the entrance to any exit of the park contains the same number of street lights. You may add an arbitrary number of street lights to each of the roads.
Input
The first line contains integer n (1 ≤ n ≤ 10) — the number of roads on the path from the entrance to any exit.
The next line contains 2n + 1 - 2 numbers a2, a3, ... a2n + 1 - 1 — the initial numbers of street lights on each road of the park. Here ai is the number of street lights on the road between squares i and <image>. All numbers ai are positive integers, not exceeding 100.
Output
Print the minimum number of street lights that we should add to the roads of the park to make Om Nom feel safe.
Examples
Input
2
1 2 3 4 5 6
Output
5
Note
Picture for the sample test. Green color denotes the additional street lights.
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int bs(int *st, int *en, int val, char c) {
int k;
if (c == 'l') k = lower_bound(st, en, val) - st;
if (c == 'u') k = upper_bound(st, en, val) - st;
return k;
}
int prime[78500];
int sieve() {
int a, b, c;
c = 0;
prime[c] = 2;
bool *m = (bool *)calloc(1000006, sizeof(bool));
for (a = 3; a <= 1000000; a = a + 2) {
if (!m[a]) {
prime[++c] = a;
for (b = 2 * a; b <= 1000000; b = b + a) m[b] = true;
}
}
free(m);
return c;
}
long long bigmod(long long i, long long pow) {
if (pow < 1) return 1;
if (pow == 1) return i % 1000000007;
long long j;
if (pow % 2) {
j = (i * bigmod(i, pow - 1)) % 1000000007;
} else {
j = bigmod(i, pow / 2);
j = (j * j) % 1000000007;
}
return j;
}
struct st {
int v;
int mx;
};
st s[100000];
int N;
int MAX;
int n;
int dfs(int i, int l) {
if (l > n) return 0;
int a, b;
b = max(dfs(i * 2, l + 1), dfs(i * 2 + 1, l + 1));
s[i].mx = s[i].v + b;
return s[i].mx;
}
int recur(int i, int l, int add) {
if (l >= n) return 0;
int a, b, c;
c = 0;
if (s[2 * i].mx + add == MAX)
b = 0;
else {
b = MAX - s[2 * i].mx - add;
s[2 * i].v = s[2 * i].v + b;
}
c = c + b + recur(2 * i, l + 1, add + s[2 * i].v);
if (s[2 * i + 1].mx + add == MAX)
b = 0;
else {
b = MAX - s[2 * i + 1].mx - add;
s[2 * i + 1].v = s[2 * i + 1].v + b;
}
c = c + b + recur(2 * i + 1, l + 1, add + s[2 * i + 1].v);
return c;
}
int main() {
int a, b, c, d, e, x, y, z;
scanf("%d", &n);
N = (1 << (n + 1)) - 1;
MAX = 0;
for (a = 2; a <= N; a++) {
scanf("%d", &s[a].v);
s[a].mx = 0;
}
MAX = dfs(1, 0);
y = recur(1, 0, 0);
cout << y << endl;
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Sasha and Ira are two best friends. But they aren’t just friends, they are software engineers and experts in artificial intelligence. They are developing an algorithm for two bots playing a two-player game. The game is cooperative and turn based. In each turn, one of the players makes a move (it doesn’t matter which player, it's possible that players turns do not alternate).
Algorithm for bots that Sasha and Ira are developing works by keeping track of the state the game is in. Each time either bot makes a move, the state changes. And, since the game is very dynamic, it will never go back to the state it was already in at any point in the past.
Sasha and Ira are perfectionists and want their algorithm to have an optimal winning strategy. They have noticed that in the optimal winning strategy, both bots make exactly N moves each. But, in order to find the optimal strategy, their algorithm needs to analyze all possible states of the game (they haven’t learned about alpha-beta pruning yet) and pick the best sequence of moves.
They are worried about the efficiency of their algorithm and are wondering what is the total number of states of the game that need to be analyzed?
Input
The first and only line contains integer N.
* 1 ≤ N ≤ 106
Output
Output should contain a single integer – number of possible states modulo 109 + 7.
Examples
Input
2
Output
19
Note
Start: Game is in state A.
* Turn 1: Either bot can make a move (first bot is red and second bot is blue), so there are two possible states after the first turn – B and C.
* Turn 2: In both states B and C, either bot can again make a turn, so the list of possible states is expanded to include D, E, F and G.
* Turn 3: Red bot already did N=2 moves when in state D, so it cannot make any more moves there. It can make moves when in state E, F and G, so states I, K and M are added to the list. Similarly, blue bot cannot make a move when in state G, but can when in D, E and F, so states H, J and L are added.
* Turn 4: Red bot already did N=2 moves when in states H, I and K, so it can only make moves when in J, L and M, so states P, R and S are added. Blue bot cannot make a move when in states J, L and M, but only when in H, I and K, so states N, O and Q are added.
Overall, there are 19 possible states of the game their algorithm needs to analyze.
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <class T>
int getbit(T s, int i) {
return (s >> i) & 1;
}
template <class T>
T gcd(T a, T b) {
T r;
while (b != 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
const long double PI = 2 * acos(0.0);
const long double eps = 1e-15;
const int infi = 1e9;
const long long Linfi = (long long)1e18;
const long long MOD = 1000000007;
const int CON = 5;
const int c2 = 37;
int n;
long long gt[2000005];
long long power(long long a, int p) {
if (p == 0) return 1;
if (p == 1) return a;
long long ans = power(a, p / 2);
ans = (ans * ans) % MOD;
if (p % 2) ans = (ans * a) % MOD;
return ans;
}
void solve() {
gt[0] = 1;
for (int i = 1; i <= 2000005 - 1; i++) gt[i] = (gt[i - 1] * i) % MOD;
long long ans = (2 * gt[2 * n - 1]) % MOD;
long long tmp = (gt[n] * gt[n - 1]) % MOD;
tmp = power(tmp, MOD - 2);
ans = ((ans * tmp) - 1 + MOD) % MOD;
cout << ans << endl;
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
n++;
solve();
return 0;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
You are given a huge integer a consisting of n digits (n is between 1 and 3 ⋅ 10^5, inclusive). It may contain leading zeros.
You can swap two digits on adjacent (neighboring) positions if the swapping digits are of different parity (that is, they have different remainders when divided by 2).
For example, if a = 032867235 you can get the following integers in a single operation:
* 302867235 if you swap the first and the second digits;
* 023867235 if you swap the second and the third digits;
* 032876235 if you swap the fifth and the sixth digits;
* 032862735 if you swap the sixth and the seventh digits;
* 032867325 if you swap the seventh and the eighth digits.
Note, that you can't swap digits on positions 2 and 4 because the positions are not adjacent. Also, you can't swap digits on positions 3 and 4 because the digits have the same parity.
You can perform any number (possibly, zero) of such operations.
Find the minimum integer you can obtain.
Note that the resulting integer also may contain leading zeros.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases in the input.
The only line of each test case contains the integer a, its length n is between 1 and 3 ⋅ 10^5, inclusive.
It is guaranteed that the sum of all values n does not exceed 3 ⋅ 10^5.
Output
For each test case print line — the minimum integer you can obtain.
Example
Input
3
0709
1337
246432
Output
0079
1337
234642
Note
In the first test case, you can perform the following sequence of operations (the pair of swapped digits is highlighted): 0 \underline{70} 9 → 0079.
In the second test case, the initial integer is optimal.
In the third test case you can perform the following sequence of operations: 246 \underline{43} 2 → 24 \underline{63}42 → 2 \underline{43} 642 → 234642.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long t;
cin >> t;
while (t--) {
string s;
cin >> s;
vector<long long> even;
vector<long long> odd;
long long n = 0;
while (s[n] != NULL) {
if ((s[n] - '0') % 2)
odd.push_back(s[n] - '0');
else
even.push_back(s[n] - '0');
n++;
}
long long i = 0;
long long j = 0;
vector<long long> v;
while (i < even.size() and j < odd.size()) {
if (even[i] >= odd[j]) {
v.push_back(odd[j]);
j++;
} else {
v.push_back(even[i]);
i++;
}
}
while (i < even.size()) {
v.push_back(even[i]);
i++;
}
while (j < odd.size()) {
v.push_back(odd[j]);
j++;
}
for (auto i : v) cout << i;
cout << endl;
}
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
You are given two positive integers a and b. There are two possible operations:
1. multiply one of the numbers by some prime p;
2. divide one of the numbers on its prime factor p.
What is the minimum number of operations required to obtain two integers having the same number of divisors? You are given several such pairs, you need to find the answer for each of them.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^5) — the number of pairs of integers for which you are to find the answer.
Each of the next t lines contain two integers a_i and b_i (1 ≤ a_i, b_i ≤ 10^6).
Output
Output t lines — the i-th of them should contain the answer for the pair a_i, b_i.
Example
Input
8
9 10
100 17
220 70
17 19
4 18
32 20
100 32
224 385
Output
1
3
1
0
1
0
1
1
Note
These are the numbers with equal number of divisors, which are optimal to obtain in the sample test case:
* (27, 10), 4 divisors
* (100, 1156), 9 divisors
* (220, 140), 12 divisors
* (17, 19), 2 divisors
* (12, 18), 6 divisors
* (50, 32), 6 divisors
* (224, 1925), 12 divisors
Note that there can be several optimal pairs of numbers.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
inline bool isp(int x) {
if (x <= 1) return 0;
for (int i = 2; i * i <= x; i++) {
if (x % i == 0) {
return 0;
}
}
return 1;
}
const int N = 1000000 + 5;
vector<vector<int>> a, b;
vector<int> cnt, aux, gen_primes;
vector<int> cntd;
inline void buildA(int i, int cur, int ant) {
a.push_back(aux);
for (int t = 1; t <= ant; t++) {
if (cur * gen_primes[i] >= N) break;
cur *= gen_primes[i];
aux.push_back(t);
buildA(i + 1, cur, t);
aux.pop_back();
}
}
inline void buildB(int cur, int ant) {
b.push_back(aux);
for (int t = 1; t <= ant; t++) {
if (cur * (t + 1) > 1000) break;
aux.push_back(t);
buildB(cur * (t + 1), t);
aux.pop_back();
}
}
int ans[290][1005];
int best[290][290];
bool p[N];
vector<int> gr[N];
int rofl[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
for (int i = 1; i <= 1000; i++) {
if (isp(i)) {
gen_primes.push_back(i);
}
}
buildA(0, 1, 1000);
buildB(1, 1000);
for (auto x : b) {
int ans = 1;
for (auto y : x) ans *= (y + 1);
cntd.push_back(ans);
}
for (int i = 0; i < a.size(); i++) {
for (int j = 1; j <= 1000; j++) ans[i][j] = 1e9;
for (int j = 0; j < b.size(); j++) {
int mx = max(a[i].size(), b[j].size()), sum = 0;
for (int t = 0; t < mx; t++) {
int add = 0;
if (t < a[i].size()) add += a[i][t];
if (t < b[j].size()) add -= b[j][t];
sum += abs(add);
}
ans[i][cntd[j]] = min(ans[i][cntd[j]], sum);
}
}
map<vector<int>, int> id;
for (int i = 0; i < a.size(); i++) {
id[a[i]] = i;
for (int j = 0; j < a.size(); j++) {
int sol = 1e9;
for (int y = 1; y <= 1000; y++) {
sol = min(sol, ans[i][y] + ans[j][y]);
}
best[i][j] = sol;
}
}
for (int i = 2; i < N; i++) p[i] = 1;
for (int i = 2; i < N; i++) {
if (p[i]) {
for (int j = i; j < N; j += i) {
if (j > i) p[j] = 0;
int aux = j, g = 0;
while (aux % i == 0) {
aux /= i;
g++;
}
gr[j].push_back(g);
}
}
}
for (int i = 1; i < N; i++) {
sort(gr[i].rbegin(), gr[i].rend());
rofl[i] = id[gr[i]];
}
int q;
cin >> q;
while (q--) {
int a, b;
cin >> a >> b;
cout << best[rofl[a]][rofl[b]] << "\n";
}
return 0;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
Given are an integer X and an integer sequence of length N: p_1, \ldots, p_N.
Among the integers not contained in the sequence p_1, \ldots, p_N (not necessarily positive), find the integer nearest to X, that is, find the integer whose absolute difference with X is the minimum. If there are multiple such integers, report the smallest such integer.
Constraints
* 1 \leq X \leq 100
* 0 \leq N \leq 100
* 1 \leq p_i \leq 100
* p_1, \ldots, p_N are all distinct.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
X N
p_1 ... p_N
Output
Print the answer.
Examples
Input
6 5
4 7 10 6 5
Output
8
Input
10 5
4 7 10 6 5
Output
9
Input
100 0
Output
100
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int x,n,p;
cin >> x >> n;
set< int > s;
for (int i=0; i<n; i++) cin >> p, s.insert(p);
int ans = 1e3, ansN = x-1;
for (int i=x-100; i<=x+100; i++) {
if (s.count(i) > 0) continue;
int v = abs(x-i);
if (v < ans) ans = v, ansN = i;
}
cout << ansN;
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
Vasya studies divisibility rules at school. Here are some of them:
* Divisibility by 2. A number is divisible by 2 if and only if its last digit is divisible by 2 or in other words, is even.
* Divisibility by 3. A number is divisible by 3 if and only if the sum of its digits is divisible by 3.
* Divisibility by 4. A number is divisible by 4 if and only if its last two digits form a number that is divisible by 4.
* Divisibility by 5. A number is divisible by 5 if and only if its last digit equals 5 or 0.
* Divisibility by 6. A number is divisible by 6 if and only if it is divisible by 2 and 3 simultaneously (that is, if the last digit is even and the sum of all digits is divisible by 3).
* Divisibility by 7. Vasya doesn't know such divisibility rule.
* Divisibility by 8. A number is divisible by 8 if and only if its last three digits form a number that is divisible by 8.
* Divisibility by 9. A number is divisible by 9 if and only if the sum of its digits is divisible by 9.
* Divisibility by 10. A number is divisible by 10 if and only if its last digit is a zero.
* Divisibility by 11. A number is divisible by 11 if and only if the sum of digits on its odd positions either equals to the sum of digits on the even positions, or they differ in a number that is divisible by 11.
Vasya got interested by the fact that some divisibility rules resemble each other. In fact, to check a number's divisibility by 2, 4, 5, 8 and 10 it is enough to check fulfiling some condition for one or several last digits. Vasya calls such rules the 2-type rules.
If checking divisibility means finding a sum of digits and checking whether the sum is divisible by the given number, then Vasya calls this rule the 3-type rule (because it works for numbers 3 and 9).
If we need to find the difference between the sum of digits on odd and even positions and check whether the difference is divisible by the given divisor, this rule is called the 11-type rule (it works for number 11).
In some cases we should divide the divisor into several factors and check whether rules of different types (2-type, 3-type or 11-type) work there. For example, for number 6 we check 2-type and 3-type rules, for number 66 we check all three types. Such mixed divisibility rules are called 6-type rules.
And finally, there are some numbers for which no rule works: neither 2-type, nor 3-type, nor 11-type, nor 6-type. The least such number is number 7, so we'll say that in such cases the mysterious 7-type rule works, the one that Vasya hasn't discovered yet.
Vasya's dream is finding divisibility rules for all possible numbers. He isn't going to stop on the decimal numbers only. As there are quite many numbers, ha can't do it all by himself. Vasya asked you to write a program that determines the divisibility rule type in the b-based notation for the given divisor d.
Input
The first input line contains two integers b and d (2 ≤ b, d ≤ 100) — the notation system base and the divisor. Both numbers are given in the decimal notation.
Output
On the first output line print the type of the rule in the b-based notation system, where the divisor is d: "2-type", "3-type", "11-type", "6-type" or "7-type". If there are several such types, print the one that goes earlier in the given sequence. If a number belongs to the 2-type, print on the second line the least number of the last b-based digits that we will need to use to check the divisibility.
Examples
Input
10 10
Output
2-type
1
Input
2 3
Output
11-type
Note
The divisibility rule for number 3 in binary notation looks as follows: "A number is divisible by 3 if and only if the sum of its digits that occupy the even places differs from the sum of digits that occupy the odd places, in a number that is divisible by 3". That's an 11-type rule. For example, 2110 = 101012. For it the sum of digits on odd positions equals 1 + 1 + 1 = 3, an on even positions — 0 + 0 = 0. The rule works and the number is divisible by 3.
In some notations a number can fit into the 3-type rule and the 11-type rule. In this case the correct answer is "3-type".
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int SITO_MAX = 100000;
int f[SITO_MAX + 1];
vector<int> prosti;
struct sito {
sito() {
for (int i = 2; i <= SITO_MAX; i++) {
if (f[i] == 0) {
f[i] = i;
prosti.push_back(i);
}
int j = 0;
while (j < (int)prosti.size()) {
if (prosti[j] > f[i]) {
break;
}
int x = i * prosti[j];
if (x > SITO_MAX) {
break;
}
f[x] = prosti[j];
j++;
}
}
}
} sito_obj_983431;
vector<pair<int, int>> factor_small(int x) {
vector<pair<int, int>> v;
while (x > 1) {
int p = f[x];
int c = 0;
while (x % p == 0) {
x /= p;
c++;
}
v.push_back({p, c});
}
return v;
}
vector<pair<int, int>> factor(int x) {
vector<pair<int, int>> v;
for (int p : prosti) {
if (x % p == 0) {
int c = 0;
while (x % p == 0) {
x /= p;
c++;
}
v.push_back({p, c});
}
}
if (x > 1) {
v.push_back({x, 1});
}
return v;
}
bool is2(long long b, long long d) {
long long p = 1;
for (int i = 1; i <= 8; i++) {
p *= b;
if (p % d == 0) {
return true;
}
}
return false;
}
bool is3(long long b, long long d) { return (b - 1) % d == 0; }
bool is11(long long b, long long d) {
return set<long long>{b % d, b * b % d} == set<long long>{1ll, d - 1};
}
bool is2311(long long b, long long d) {
return is2(b, d) || is3(b, d) || is11(b, d);
}
long long pw(long long x, long long y) {
long long p = 1;
while (y--) p *= x;
return p;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cerr.tie(nullptr);
long long b, d;
cin >> b >> d;
{
long long p = 1;
for (int i = 1; i <= 8; i++) {
p *= b;
if (p % d == 0) {
cout << "2-type\n" << i << '\n';
return 0;
}
}
}
if (is3(b, d)) {
cout << "3-type\n";
return 0;
}
if (is11(b, d)) {
cout << "11-type\n";
return 0;
}
bool ok = 1;
for (auto p : factor_small(d)) ok &= is2311(b, pw(p.first, p.second));
if (ok) {
cout << "6-type\n";
return 0;
}
cout << "7-type\n";
}
``` |
### Prompt
Create a solution in CPP for the following problem:
You are given an image, that can be represented with a 2-d n by m grid of pixels. Each pixel of the image is either on or off, denoted by the characters "0" or "1", respectively. You would like to compress this image. You want to choose an integer k > 1 and split the image into k by k blocks. If n and m are not divisible by k, the image is padded with only zeros on the right and bottom so that they are divisible by k. Each pixel in each individual block must have the same value. The given image may not be compressible in its current state. Find the minimum number of pixels you need to toggle (after padding) in order for the image to be compressible for some k. More specifically, the steps are to first choose k, then the image is padded with zeros, then, we can toggle the pixels so it is compressible for this k. The image must be compressible in that state.
Input
The first line of input will contain two integers n, m (2 ≤ n, m ≤ 2 500), the dimensions of the image.
The next n lines of input will contain a binary string with exactly m characters, representing the image.
Output
Print a single integer, the minimum number of pixels needed to toggle to make the image compressible.
Example
Input
3 5
00100
10110
11001
Output
5
Note
We first choose k = 2.
The image is padded as follows:
001000
101100
110010
000000
We can toggle the image to look as follows:
001100
001100
000000
000000
We can see that this image is compressible for k = 2.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e3 + 5e2 + 5;
const int inf = 0x3f3f3f3f;
int mp[maxn][maxn];
char a[maxn];
int n, m;
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%s", a + 1);
for (int j = 1; j <= m; j++) {
if (a[j] == '1') mp[i][j] = 1;
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
mp[i][j] = mp[i - 1][j] + mp[i][j - 1] + mp[i][j] - mp[i - 1][j - 1];
}
}
int ans = inf;
int len = max(n, m);
for (int k = 2; k <= len; k++) {
int nn = n, mm = m;
if (n % k != 0) nn = (n / k) * k + k;
if (m % k != 0) mm = (m / k) * k + k;
int tmp1 = 0;
for (int i = 1; i <= nn / k; i++)
for (int j = 1; j <= mm / k; j++) {
int x1 = i * k > n ? n : i * k;
int y1 = j * k > m ? m : j * k;
int x2 = i * k - k + 1 > n ? n : i * k - k + 1;
int y2 = j * k - k + 1 > m ? m : j * k - k + 1;
int tmp =
mp[x1][y1] + mp[x2 - 1][y2 - 1] - mp[x1][y2 - 1] - mp[x2 - 1][y1];
if (tmp <= k * k / 2) {
tmp1 += (tmp);
} else {
tmp1 += (k * k - tmp);
}
}
ans = min(ans, tmp1);
}
printf("%d\n", ans);
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
You are given undirected weighted graph. Find the length of the shortest cycle which starts from the vertex 1 and passes throught all the edges at least once. Graph may contain multiply edges between a pair of vertices and loops (edges from the vertex to itself).
Input
The first line of the input contains two integers n and m (1 ≤ n ≤ 15, 0 ≤ m ≤ 2000), n is the amount of vertices, and m is the amount of edges. Following m lines contain edges as a triples x, y, w (1 ≤ x, y ≤ n, 1 ≤ w ≤ 10000), x, y are edge endpoints, and w is the edge length.
Output
Output minimal cycle length or -1 if it doesn't exists.
Examples
Input
3 3
1 2 1
2 3 1
3 1 1
Output
3
Input
3 2
1 2 3
2 3 4
Output
14
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<int> deg(16);
vector<vector<int>> dist(16, vector<int>(16, 1000000000));
vector<int> temp(16);
int timer = 1;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
int x, y, w;
long long res = 0;
for (int i = 1; i <= n; i += 1) {
dist[i][i] = 0;
}
for (int i = 1; i <= m; i += 1) {
cin >> x >> y >> w;
res += w;
deg[x] += 1;
deg[y] += 1;
dist[x][y] = dist[y][x] = min(dist[x][y], w);
}
for (int k = 1; k <= n; k += 1) {
for (int i = 1; i <= n; i += 1) {
for (int j = 1; j <= n; j += 1) {
if (dist[i][k] + dist[k][j] < dist[i][j]) {
dist[i][j] = dist[i][k] + dist[k][j];
}
}
}
}
for (int i = 2; i <= n; i += 1) {
if (deg[i] && dist[1][i] == 1000000000) {
cout << -1;
return 0;
}
}
for (int i = 1; i <= n; i += 1) {
if (deg[i] & 1) {
temp[timer++] = i;
}
}
timer -= 1;
vector<int> dp((1 << timer), 1000000000);
dp[0] = 0;
for (int mask = 0; mask < (1 << timer); mask += 1) {
for (int i = 1; i <= timer; i += 1) {
for (int j = 1; j <= timer; j += 1) {
if (i == j || ((1 << (i - 1)) | mask) == mask ||
((1 << (j - 1)) | mask) == mask) {
continue;
}
dp[mask | (1 << (i - 1)) | (1 << (j - 1))] =
min(dp[mask | (1 << (i - 1)) | (1 << (j - 1))],
dp[mask] + dist[temp[i]][temp[j]]);
}
}
}
cout << res + dp[(1 << timer) - 1];
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
This is an interactive problem.
Homer likes arrays a lot and he wants to play a game with you.
Homer has hidden from you a permutation a_1, a_2, ..., a_n of integers 1 to n. You are asked to find any index k (1 ≤ k ≤ n) which is a local minimum.
For an array a_1, a_2, ..., a_n, an index i (1 ≤ i ≤ n) is said to be a local minimum if a_i < min\\{a_{i-1},a_{i+1}\}, where a_0 = a_{n+1} = +∞. An array is said to be a permutation of integers 1 to n, if it contains all integers from 1 to n exactly once.
Initially, you are only given the value of n without any other information about this permutation.
At each interactive step, you are allowed to choose any i (1 ≤ i ≤ n) and make a query with it. As a response, you will be given the value of a_i.
You are asked to find any index k which is a local minimum after at most 100 queries.
Interaction
You begin the interaction by reading an integer n (1≤ n ≤ 10^5) on a separate line.
To make a query on index i (1 ≤ i ≤ n), you should output "? i" in a separate line. Then read the value of a_i in a separate line. The number of the "?" queries is limited within 100.
When you find an index k (1 ≤ k ≤ n) which is a local minimum, output "! k" in a separate line and terminate your program.
In case your query format is invalid, or you have made more than 100 "?" queries, you will receive Wrong Answer verdict.
After printing a query do not forget to output end of line and flush the output. Otherwise, you will get Idleness limit exceeded. To do this, use:
* fflush(stdout) or cout.flush() in C++;
* System.out.flush() in Java;
* flush(output) in Pascal;
* stdout.flush() in Python;
* see documentation for other languages.
Hack Format
The first line of the hack should contain a single integer n (1 ≤ n ≤ 10^5).
The second line should contain n distinct integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n).
Example
Input
5
3
2
1
4
5
Output
? 1
? 2
? 3
? 4
? 5
! 3
Note
In the example, the first line contains an integer 5 indicating that the length of the array is n = 5.
The example makes five "?" queries, after which we conclude that the array is a = [3,2,1,4,5] and k = 3 is local minimum.
### Response
```cpp
# include<bits/stdc++.h>
using namespace std ;
# define f first
# define s second
# define ll long long
# define pb push_back
# define mp make_pair
# define INF INT_MAX
# define INFL 1e18+10
# define mod 1000000007
# define rep( i , s , e ) for( int i = s ; i <= e ; i++ )
# define repR( i , e , s ) for( int i = e ; i >= s ; i-- )
const int maxN = 100001 ;
int arr[maxN] ;
int query( int id ) {
if ( arr[id] ) return arr[id] ;
cout << "? " << id << endl ;
int a ; cin >> a ; return arr[id] = a ;
}
void ans( int id ) { cout << "! " << id ; exit(0) ; }
void solve() {
int n ; cin >> n ;
if ( n == 1 ) ans(1) ;
int a = query(1) , b = query(2) ;
if ( a < b ) ans(1) ;
int c = query( n - 1 ) , d = query(n) ;
if ( d < c ) ans(n) ;
int l = 2 , r = n - 1 ;
while ( l < r ) {
int mid = ( l + r ) / 2 ;
a = query( mid - 1 ) , b = query( mid ) , c = query( mid + 1 ) ;
if ( a > b ) {
if ( c > b ) ans( mid ) ;
l = mid ;
}
else r = mid ;
}
ans(l) ;
}
int main() {
ios_base::sync_with_stdio( false ) ;
cin.tie(0) , cout.tie(0) ;
solve() ; return 0 ;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
Many modern text editors automatically check the spelling of the user's text. Some editors even suggest how to correct typos.
In this problem your task to implement a small functionality to correct two types of typos in a word. We will assume that three identical letters together is a typo (for example, word "helllo" contains a typo). Besides, a couple of identical letters immediately followed by another couple of identical letters is a typo too (for example, words "helloo" and "wwaatt" contain typos).
Write a code that deletes the minimum number of letters from a word, correcting described typos in the word. You are allowed to delete letters from both ends and from the middle of the word.
Input
The single line of the input contains word s, its length is from 1 to 200000 characters. The given word s consists of lowercase English letters.
Output
Print such word t that it doesn't contain any typos described in the problem statement and is obtained from s by deleting the least number of letters.
If there are multiple solutions, print any of them.
Examples
Input
helloo
Output
hello
Input
woooooow
Output
woow
Note
The second valid answer to the test from the statement is "heloo".
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 1e9 + 7;
const long long int INF = 1000000005;
const long long int MAX_N = 1e5 + 7;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
string s, t = "";
cin >> s;
vector<pair<int, int> > v;
int n = s.length();
for (int i = 0; i < n; ++i) {
char c = s[i];
int len = 0, start = i;
while (c == s[i] && i < n) {
len++;
i++;
}
i--;
if (len >= 3) v.push_back({start, i});
}
int j = 0;
for (int i = 0; i < s.length(); ++i) {
if (j < v.size() && v[j].first == i) {
t += s[v[j].first];
t += s[v[j].second];
i = v[j].second;
j++;
} else
t += s[i];
}
vector<int> invalid;
n = t.length();
for (int i = 0; i < n; i++) {
char c = t[i];
int len = 0;
while (c == t[i] && i < n) {
len++;
i++;
}
if (len == 2 && i < n) {
char c1 = t[i];
int len1 = 0;
while (c1 == t[i] && i < n) {
len1++;
i++;
}
i--;
if (len1 == 2) invalid.push_back(i);
} else
i--;
}
j = 0;
for (int i = 0; i < t.length(); i++) {
if (j < invalid.size() && i == invalid[j]) {
j++;
continue;
}
cout << t[i];
}
return 0;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
Heiankyo is known as a town with a grid of roads.
Hokusai, a cat who lives in Heiankyo, has to go from his home to a secret place on the outskirts of town every day for patrol. However, I get tired of following the same path every day, and there is a risk of being followed, so Hokusai wants to use a different route every day as much as possible. On the other hand, Hokusai has a troublesome smell, so I don't want to go down the road away from my destination.
There are Actinidia polygama on the roads here and there in Heiankyo, and Hokusai cannot go through the road where Actinidia polygama is falling. This is because if you go through such a road, you will be sick. Fortunately, there are no Actinidia polygama at the intersection.
Hokusai wants to know the number of possible routes from his home to a secret place. Here, Hokusai's home is at (0, 0) and the secret place is at (gx, gy). The roads are laid out in a grid with x = i (i is an integer) and y = j (j is an integer).
Notes on Submission
Multiple datasets are given in the above format. The first line of input data gives the number of datasets. Create a program that outputs the output for each data set in order in the above format.
Input
The first line of input is given the coordinates of the secret location (gx, gy). All of these are integers between 1 and 15 and are given separated by a single space. The second line is given the number of sections where Actinidia polygama is falling p (0 ≤ p ≤ 100), and the following lines p are given one section for each line where Actinidia polygama is falling. The p sections are different from each other. One interval is expressed in the form of x1 y1 x2 y2 and is a line segment of length 1 parallel to the x-axis or y-axis, with (x1, y1) and (x2, y2) as endpoints. x1 and x2 are in the range [0, gx] and y1 and y2 are in the range [0, gy].
Output
Output the number of possible routes. If there is no possible route, output "Miserable Hokusai!" On one line.
Example
Input
4
2 2
0
1 1
2
0 0 0 1
0 0 1 0
4 3
4
1 0 0 0
3 3 4 3
4 1 4 0
0 2 0 3
15 15
0
Output
6
Miserable Hokusai!
5
155117520
### Response
```cpp
#include<iostream>
using namespace std;
#define MAX 20
#define rep(i, n) for ( int i = 0; i < n; i++ )
void compute(){
int gy, gx, n, sx, sy, tx, ty;
bool G[MAX+1][MAX+1][MAX+1][MAX+1];
int T[MAX+1][MAX+1];
rep(i,MAX+1) rep(j,MAX+1) rep(k,MAX+1) rep(m,MAX+1) G[i][j][k][m] = false;
rep(i, MAX+1) rep(j, MAX+1) T[i][j] = 0;
cin >> gx >> gy >> n;
rep(i, n){
cin >> sx >> sy >> tx >> ty;
G[sy][sx][ty][tx] = true;
G[ty][tx][sy][sx] = true;
}
T[0][0] = 1;
rep(y, gy+1) rep(x, gx+1){
if ( x < gx && !G[y][x][y][x+1]) T[y][x+1] += T[y][x];
if ( y < gy && !G[y][x][y+1][x]) T[y+1][x] += T[y][x];
}
if ( T[gy][gx] == 0 ) cout << "Miserable Hokusai!" << endl;
else cout << T[gy][gx] << endl;
}
int main(){
int tcase; cin >> tcase;
for ( int i = 0; i < tcase; i++ ) compute();
}
``` |
### Prompt
Generate a CPP solution to the following problem:
Write a program which reads a sequence A of n elements and an integer M, and outputs "yes" if you can make M by adding elements in A, otherwise "no". You can use an element only once.
You are given the sequence A and q questions where each question contains Mi.
Notes
You can solve this problem by a Burte Force approach. Suppose solve(p, t) is a function which checkes whether you can make t by selecting elements after p-th element (inclusive). Then you can recursively call the following functions:
solve(0, M)
solve(1, M-{sum created from elements before 1st element})
solve(2, M-{sum created from elements before 2nd element})
...
The recursive function has two choices: you selected p-th element and not. So, you can check solve(p+1, t-A[p]) and solve(p+1, t) in solve(p, t) to check the all combinations.
For example, the following figure shows that 8 can be made by A[0] + A[2].
<image>
Constraints
* n ≤ 20
* q ≤ 200
* 1 ≤ elements in A ≤ 2000
* 1 ≤ Mi ≤ 2000
Input
In the first line n is given. In the second line, n integers are given. In the third line q is given. Then, in the fourth line, q integers (Mi) are given.
Output
For each question Mi, print yes or no.
Example
Input
5
1 5 7 10 21
8
2 4 17 8 22 21 100 35
Output
no
no
yes
yes
yes
yes
no
no
### Response
```cpp
#include<iostream>
using namespace std;
int n, q, m, a[20];
bool solve(int i, int m){
if(m == 0) return true;
if(i == n) return false;
bool res = solve(i + 1, m) || solve(i + 1, m - a[i]);
return res;
}
int main(){
cin >> n;
for(int i=0; i<n; ++i) cin >> a[i];
cin >> q;
while(q--){
cin >> m;
cout << (solve(0, m) ? "yes" : "no") << endl;
}
}
``` |
### Prompt
Generate a CPP solution to the following problem:
You are given a set S of strings consisting of `0` and `1`, and an integer K.
Find the longest string that is a subsequence of K or more different strings in S. If there are multiple strings that satisfy this condition, find the lexicographically smallest such string.
Here, S is given in the format below:
* The data directly given to you is an integer N, and N+1 strings X_0,X_1,...,X_N. For every i (0\leq i\leq N), the length of X_i is 2^i.
* For every pair of two integers (i,j) (0\leq i\leq N,0\leq j\leq 2^i-1), the j-th character of X_i is `1` if and only if the binary representation of j with i digits (possibly with leading zeros) belongs to S. Here, the first and last characters in X_i are called the 0-th and (2^i-1)-th characters, respectively.
* S does not contain a string with length N+1 or more.
Here, a string A is a subsequence of another string B when there exists a sequence of integers t_1 < ... < t_{|A|} such that, for every i (1\leq i\leq |A|), the i-th character of A and the t_i-th character of B is equal.
Constraints
* 0 \leq N \leq 20
* X_i(0\leq i\leq N) is a string of length 2^i consisting of `0` and `1`.
* 1 \leq K \leq |S|
* K is an integer.
Input
Input is given from Standard Input in the following format:
N K
X_0
:
X_N
Output
Print the lexicographically smallest string among the longest strings that are subsequences of K or more different strings in S.
Examples
Input
3 4
1
01
1011
01001110
Output
10
Input
4 6
1
01
1011
10111010
1101110011111101
Output
100
Input
2 5
0
11
1111
Output
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
typedef signed long long ll;
#undef _P
#define _P(...) (void)printf(__VA_ARGS__)
#define FOR(x,to) for(x=0;x<(to);x++)
#define FORR(x,arr) for(auto& x:arr)
#define ITR(x,c) for(__typeof(c.begin()) x=c.begin();x!=c.end();x++)
#define ALL(a) (a.begin()),(a.end())
#define ZERO(a) memset(a,0,sizeof(a))
#define MINUS(a) memset(a,0xff,sizeof(a))
//-------------------------------------------------------
int N,K;
string S[21];
int cnt[21][1<<21];
int R[21][2];
int ID(int L,int x) {
return (1<<L) + x;
}
void solve() {
int i,j,k,l,r,x,y; string s;
cin>>N>>K;
FOR(i,N+1) {
cin>>S[i];
FOR(x,1<<i) cnt[0][ID(i,x)]=S[i][x]=='1';
}
for(i=N;i>=0;i--) {
FOR(x,1<<i) {
R[i][0]=R[i][1]=i;
for(j=i-1;j>=0;j--) {
R[j][0]=R[j+1][0];
R[j][1]=R[j+1][1];
int prefix = x>>(i-1-j);
R[j][prefix&1]=j;
}
FOR(j,i) {
int prefix = x>>(i-j);
cnt[j][ID(j,prefix)]+=cnt[j][ID(i,x)];
if(R[j][0]<i) {
int nex=(prefix<<(i-R[j][0])) | (x&((1<<(i-R[j][0]))-1));
cnt[j+1][ID(j+i-R[j][0],nex)]+=cnt[j][ID(i,x)];
}
if(R[j][1]<i) {
int nex=(prefix<<(i-R[j][1])) | (x&((1<<(i-R[j][1]))-1));
cnt[j+1][ID(j+i-R[j][1],nex)]+=cnt[j][ID(i,x)];
}
}
if(cnt[i][ID(i,x)]>=K) {
FOR(j,i) cout<<((x>>(i-1-j))&1);
cout<<endl;
return;
}
}
}
}
int main(int argc,char** argv){
string s;int i;
if(argc==1) ios::sync_with_stdio(false), cin.tie(0);
FOR(i,argc-1) s+=argv[i+1],s+='\n'; FOR(i,s.size()) ungetc(s[s.size()-1-i],stdin);
cout.tie(0); solve(); return 0;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
Fibonacci numbers have the following form:
F1 = 1, F2 = 2, Fi = Fi - 1 + Fi - 2, i > 2.
Let's consider some non-empty set S = {s1, s2, ..., sk}, consisting of different Fibonacci numbers. Let's find the sum of values of this set's elements:
<image>
Let's call the set S a number n's decomposition into Fibonacci sum.
It's easy to see that several numbers have several decompositions into Fibonacci sum. For example, for 13 we have 13, 5 + 8, 2 + 3 + 8 — three decompositions, and for 16: 3 + 13, 1 + 2 + 13, 3 + 5 + 8, 1 + 2 + 5 + 8 — four decompositions.
By the given number n determine the number of its possible different decompositions into Fibonacci sum.
Input
The first line contains an integer t — the number of tests (1 ≤ t ≤ 105). Each of the following t lines contains one test.
Each test is an integer n (1 ≤ n ≤ 1018).
Please do not use the %lld specificator to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specificator.
Output
For each input data test print a single number on a single line — the answer to the problem.
Examples
Input
2
13
16
Output
3
4
Note
Two decompositions are different if there exists a number that is contained in the first decomposition, but is not contained in the second one. Decompositions that differ only in the order of summands are considered equal.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<long long> fib;
vector<int> v;
long long f[100][2];
int main() {
fib.push_back(1);
fib.push_back(1);
while (true) {
long long a = fib.back() + fib[fib.size() - 2];
if (a > 1e18) break;
fib.push_back(a);
}
int test;
scanf("%d", &test);
for (int cas = 1; cas <= test; ++cas) {
long long n;
scanf("%I64d", &n);
v.clear();
for (int i = fib.size() - 1; i > 0; --i)
if (n >= fib[i]) {
v.push_back(i);
n -= fib[i];
}
v.push_back(0);
reverse(v.begin(), v.end());
f[0][1] = 1;
f[0][0] = 0;
int k = v.size() - 1;
for (int i = 1; i <= k; ++i) {
f[i][1] = f[i - 1][1] + f[i - 1][0];
f[i][0] = (v[i] - v[i - 1] - 1) / 2 * f[i - 1][1] +
(v[i] - v[i - 1]) / 2 * f[i - 1][0];
}
printf("%I64d\n", f[k][1] + f[k][0]);
}
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
Vasily the Programmer loves romance, so this year he decided to illuminate his room with candles.
Vasily has a candles.When Vasily lights up a new candle, it first burns for an hour and then it goes out. Vasily is smart, so he can make b went out candles into a new candle. As a result, this new candle can be used like any other new candle.
Now Vasily wonders: for how many hours can his candles light up the room if he acts optimally well? Help him find this number.
Input
The single line contains two integers, a and b (1 ≤ a ≤ 1000; 2 ≤ b ≤ 1000).
Output
Print a single integer — the number of hours Vasily can light up the room for.
Examples
Input
4 2
Output
7
Input
6 3
Output
8
Note
Consider the first sample. For the first four hours Vasily lights up new candles, then he uses four burned out candles to make two new ones and lights them up. When these candles go out (stop burning), Vasily can make another candle. Overall, Vasily can light up the room for 7 hours.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
int ans = a;
while (a >= b) {
int tmp = 0;
if (a % b != 0) tmp = a % b;
a /= b;
ans += a;
a += tmp;
}
cout << ans;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
Sometimes some words like "localization" or "internationalization" are so long that writing them many times in one text is quite tiresome.
Let's consider a word too long, if its length is strictly more than 10 characters. All too long words should be replaced with a special abbreviation.
This abbreviation is made like this: we write down the first and the last letter of a word and between them we write the number of letters between the first and the last letters. That number is in decimal system and doesn't contain any leading zeroes.
Thus, "localization" will be spelt as "l10n", and "internationalization» will be spelt as "i18n".
You are suggested to automatize the process of changing the words with abbreviations. At that all too long words should be replaced by the abbreviation and the words that are not too long should not undergo any changes.
Input
The first line contains an integer n (1 ≤ n ≤ 100). Each of the following n lines contains one word. All the words consist of lowercase Latin letters and possess the lengths of from 1 to 100 characters.
Output
Print n lines. The i-th line should contain the result of replacing of the i-th word from the input data.
Examples
Input
4
word
localization
internationalization
pneumonoultramicroscopicsilicovolcanoconiosis
Output
word
l10n
i18n
p43s
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i;
cin >> n;
string arr[n];
for (i = 0; i < n; i++) {
cin >> arr[i];
}
for (i = 0; i < n; i++) {
if (arr[i].length() <= 10) {
cout << arr[i] << endl;
} else
cout << arr[i].at(0) << arr[i].length() - 2
<< arr[i].at(arr[i].length() - 1) << endl;
}
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
A positive (strictly greater than zero) integer is called round if it is of the form d00...0. In other words, a positive integer is round if all its digits except the leftmost (most significant) are equal to zero. In particular, all numbers from 1 to 9 (inclusive) are round.
For example, the following numbers are round: 4000, 1, 9, 800, 90. The following numbers are not round: 110, 707, 222, 1001.
You are given a positive integer n (1 ≤ n ≤ 10^4). Represent the number n as a sum of round numbers using the minimum number of summands (addends). In other words, you need to represent the given number n as a sum of the least number of terms, each of which is a round number.
Input
The first line contains an integer t (1 ≤ t ≤ 10^4) — the number of test cases in the input. Then t test cases follow.
Each test case is a line containing an integer n (1 ≤ n ≤ 10^4).
Output
Print t answers to the test cases. Each answer must begin with an integer k — the minimum number of summands. Next, k terms must follow, each of which is a round number, and their sum is n. The terms can be printed in any order. If there are several answers, print any of them.
Example
Input
5
5009
7
9876
10000
10
Output
2
5000 9
1
7
4
800 70 6 9000
1
10000
1
10
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void digits(int n) {
vector<int> d1;
int s = 0;
int t = 1;
while (n != 0) {
t = t * 10;
if (n % 10 != 0) {
s++;
}
d1.push_back(n % 10);
n = n / 10;
}
t = t / 10;
cout << s << endl;
for (int i = d1.size() - 1; i >= 0; i--) {
if (i == 0 && d1.at(i) != 0) {
cout << d1.at(i) << " ";
t = t / 10;
;
continue;
}
if (d1.at(i) == 0) {
t = t / 10;
} else {
cout << d1.at(i) * t << " ";
t = t / 10;
}
}
cout << endl;
}
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t) {
int n;
cin >> n;
digits(n);
t--;
}
return 0;
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
There are some beautiful girls in Arpa’s land as mentioned before.
Once Arpa came up with an obvious problem:
Given an array and a number x, count the number of pairs of indices i, j (1 ≤ i < j ≤ n) such that <image>, where <image> is bitwise xor operation (see notes for explanation).
<image>
Immediately, Mehrdad discovered a terrible solution that nobody trusted. Now Arpa needs your help to implement the solution to that problem.
Input
First line contains two integers n and x (1 ≤ n ≤ 105, 0 ≤ x ≤ 105) — the number of elements in the array and the integer x.
Second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 105) — the elements of the array.
Output
Print a single integer: the answer to the problem.
Examples
Input
2 3
1 2
Output
1
Input
6 1
5 1 2 3 4 1
Output
2
Note
In the first sample there is only one pair of i = 1 and j = 2. <image> so the answer is 1.
In the second sample the only two pairs are i = 3, j = 4 (since <image>) and i = 1, j = 5 (since <image>).
A bitwise xor takes two bit integers of equal length and performs the logical xor operation on each pair of corresponding bits. The result in each position is 1 if only the first bit is 1 or only the second bit is 1, but will be 0 if both are 0 or both are 1. You can read more about bitwise xor operation here: <https://en.wikipedia.org/wiki/Bitwise_operation#XOR>.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long n, x, ar[100001], ans = 0;
int main() {
cin >> n >> x;
for (int i = 1; i <= n; i++) {
int tem;
cin >> tem;
ar[tem]++;
}
for (int i = 1; i < 100001; i++) {
int t = x ^ i;
if (i == t)
ans += ar[i] * (ar[i] - 1);
else if (t < 100001)
ans += ar[i] * ar[t];
}
cout << ans / 2 << endl;
return 0;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
There are N points in a two-dimensional plane. The initial coordinates of the i-th point are (x_i, y_i). Now, each point starts moving at a speed of 1 per second, in a direction parallel to the x- or y- axis. You are given a character d_i that represents the specific direction in which the i-th point moves, as follows:
* If d_i = `R`, the i-th point moves in the positive x direction;
* If d_i = `L`, the i-th point moves in the negative x direction;
* If d_i = `U`, the i-th point moves in the positive y direction;
* If d_i = `D`, the i-th point moves in the negative y direction.
You can stop all the points at some moment of your choice after they start moving (including the moment they start moving). Then, let x_{max} and x_{min} be the maximum and minimum among the x-coordinates of the N points, respectively. Similarly, let y_{max} and y_{min} be the maximum and minimum among the y-coordinates of the N points, respectively.
Find the minimum possible value of (x_{max} - x_{min}) \times (y_{max} - y_{min}) and print it.
Constraints
* 1 \leq N \leq 10^5
* -10^8 \leq x_i,\ y_i \leq 10^8
* x_i and y_i are integers.
* d_i is `R`, `L`, `U`, or `D`.
Input
Input is given from Standard Input in the following format:
N
x_1 y_1 d_1
x_2 y_2 d_2
.
.
.
x_N y_N d_N
Output
Print the minimum possible value of (x_{max} - x_{min}) \times (y_{max} - y_{min}).
The output will be considered correct when its absolute or relative error from the judge's output is at most 10^{-9}.
Examples
Input
2
0 3 D
3 0 L
Output
0
Input
5
-7 -10 U
7 -6 U
-8 7 D
-3 3 D
0 -6 R
Output
97.5
Input
20
6 -10 R
-4 -9 U
9 6 D
-3 -2 R
0 7 D
4 5 D
10 -10 U
-1 -8 U
10 -6 D
8 -5 U
6 4 D
0 3 D
7 9 R
9 -4 R
3 10 D
1 9 U
1 -6 U
9 -8 R
6 7 D
7 -3 D
Output
273
### Response
```cpp
#include<iostream>
#include<cstdio>
#include<cstring>
#include<ctime>
#include<cstdlib>
#include<algorithm>
#include<cmath>
#include<string>
#include<queue>
#include<vector>
#include<map>
#include<set>
#include<utility>
#include<iomanip>
#define FOR(i,a,b) for(int i=a;i<=b;i++)
using namespace std;
typedef unsigned long long ULL;
typedef long long ll;
int n;
struct node{
double x,y;
char dir[4];
}A[100050];
double cal(double x){
double ml=1e10,mr=-1e10,mu=-1e10,md=1e10;
FOR(i,1,n){
pair<double,double>tmp;
tmp.first=A[i].x,tmp.second=A[i].y;
switch(A[i].dir[0]){
case 'U':tmp.second+=x;break;
case 'D':tmp.second-=x;break;
case 'L':tmp.first-=x;break;
case 'R':tmp.first+=x;break;
}
ml=min(ml,tmp.first);
mr=max(mr,tmp.first);
mu=max(mu,tmp.second);
md=min(md,tmp.second);
}
//cout<<x<<" "<<(mr-ml)*(mu-md)<<endl;
return (mr-ml)*(mu-md);
}
int main(){
cin>>n;
FOR(i,1,n){
scanf("%lf%lf%s",&A[i].x,&A[i].y,A[i].dir);
}
double l=0,r=1e12,ans=1e18;
FOR(k,0,300){
double m1=(l+(r-l)/3),m2=(l+(r-l)*2/3);
double tmp1=cal(m1),tmp2=cal(m2);
if(tmp1>tmp2)l=m1;
else r=m2;
ans=min(ans,tmp1);
ans=min(ans,tmp2);
}
printf("%.10f",ans);
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
This is the easy version of the problem. The difference is constraints on the number of wise men and the time limit. You can make hacks only if all versions of this task are solved.
n wise men live in a beautiful city. Some of them know each other.
For each of the n! possible permutations p_1, p_2, …, p_n of the wise men, let's generate a binary string of length n-1: for each 1 ≤ i < n set s_i=1 if p_i and p_{i+1} know each other, and s_i=0 otherwise.
For all possible 2^{n-1} binary strings, find the number of permutations that produce this binary string.
Input
The first line of input contains one integer n (2 ≤ n ≤ 14) — the number of wise men in the city.
The next n lines contain a binary string of length n each, such that the j-th character of the i-th string is equal to '1' if wise man i knows wise man j, and equals '0' otherwise.
It is guaranteed that if the i-th man knows the j-th man, then the j-th man knows i-th man and no man knows himself.
Output
Print 2^{n-1} space-separated integers. For each 0 ≤ x < 2^{n-1}:
* Let's consider a string s of length n-1, such that s_i = ⌊ \frac{x}{2^{i-1}} ⌋ mod 2 for all 1 ≤ i ≤ n - 1.
* The (x+1)-th number should be equal to the required answer for s.
Examples
Input
3
011
101
110
Output
0 0 0 6
Input
4
0101
1000
0001
1010
Output
2 2 6 2 2 6 2 2
Note
In the first test, each wise man knows each other, so every permutation will produce the string 11.
In the second test:
* If p = \{1, 2, 3, 4\}, the produced string is 101, because wise men 1 and 2 know each other, 2 and 3 don't know each other, and 3 and 4 know each other;
* If p = \{4, 1, 2, 3\}, the produced string is 110, because wise men 1 and 4 know each other, 1 and 2 know each other and 2, and 3 don't know each other;
* If p = \{1, 3, 2, 4\}, the produced string is 000, because wise men 1 and 3 don't know each other, 3 and 2 don't know each other, and 2 and 4 don't know each other.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
mt19937 mt(736);
void solve(istream &cin = std::cin, ostream &cout = std::cout) {
int n;
cin >> n;
vector<vector<bool>> gr(n, vector<bool>(n));
for (auto &row : gr) {
string str;
cin >> str;
for (int i = 0; i < str.size(); i++) row[i] = str[i] == '1';
}
vector<vector<vector<ll>>> dp(gr.size(), vector<vector<ll>>(1u << gr.size()));
for (auto &row : dp)
for (unsigned mask = 1; mask < row.size(); mask++)
row[mask].resize(1u << (unsigned)(__builtin_popcount(mask) - 1));
for (unsigned i = 0; i < gr.size(); i++) dp[i][1u << i][0] = 1;
for (unsigned mask = 0; mask < dp.front().size(); mask++)
for (int last = 0; last < n; last++)
for (unsigned type = 0; type < dp[last][mask].size(); type++)
for (size_t i = 0; i < gr.size(); i++)
if (((1u << i) & mask) == 0)
dp[i][mask | (1u << i)][(type << 1u) | (gr[last][i] ? 1u : 0u)] +=
dp[last][mask][type];
for (unsigned i = 0; i < (1u << (gr.size() - 1)); i++) {
ll cnt = 0;
for (int j = 0; j < gr.size(); j++) cnt += dp[j].back()[i];
cout << cnt << ' ';
}
cout << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout << fixed;
solve();
return 0;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
In this problem we consider a very simplified model of Barcelona city.
Barcelona can be represented as a plane with streets of kind x = c and y = c for every integer c (that is, the rectangular grid). However, there is a detail which makes Barcelona different from Manhattan. There is an avenue called Avinguda Diagonal which can be represented as a the set of points (x, y) for which ax + by + c = 0.
One can walk along streets, including the avenue. You are given two integer points A and B somewhere in Barcelona. Find the minimal possible distance one needs to travel to get to B from A.
Input
The first line contains three integers a, b and c (-10^9≤ a, b, c≤ 10^9, at least one of a and b is not zero) representing the Diagonal Avenue.
The next line contains four integers x_1, y_1, x_2 and y_2 (-10^9≤ x_1, y_1, x_2, y_2≤ 10^9) denoting the points A = (x_1, y_1) and B = (x_2, y_2).
Output
Find the minimum possible travel distance between A and B. Your answer is considered correct if its absolute or relative error does not exceed 10^{-6}.
Formally, let your answer be a, and the jury's answer be b. Your answer is accepted if and only if \frac{|a - b|}{max{(1, |b|)}} ≤ 10^{-6}.
Examples
Input
1 1 -3
0 3 3 0
Output
4.2426406871
Input
3 1 -9
0 3 3 -1
Output
6.1622776602
Note
The first example is shown on the left picture while the second example us shown on the right picture below. The avenue is shown with blue, the origin is shown with the black dot.
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
double a, b, c, ret, ans[4];
struct POINT {
double x, y;
void get() { scanf("%lf%lf", &x, &y); }
} A, B, C, D;
double dis(const POINT& AA, const POINT& BB) {
return sqrt((AA.x - BB.x) * (AA.x - BB.x) + (AA.y - BB.y) * (AA.y - BB.y));
}
void deal() {
ret = fabs(A.x - B.x) + fabs(A.y - B.y);
C.y = A.y;
C.x = -b / a * C.y - c / a;
D.y = B.y;
D.x = -b / a * D.y - c / a;
ans[0] = dis(A, C) + dis(B, D) + dis(C, D);
C.x = A.x;
C.y = -a / b * C.x - c / b;
D.x = B.x;
D.y = -a / b * D.x - c / b;
ans[1] = dis(A, C) + dis(B, D) + dis(C, D);
C.x = A.x;
C.y = -a / b * C.x - c / b;
D.y = B.y;
D.x = -b / a * D.y - c / a;
ans[2] = dis(A, C) + dis(B, D) + dis(C, D);
C.y = A.y;
C.x = -b / a * C.y - c / a;
D.x = B.x;
D.y = -a / b * D.x - c / b;
ans[3] = dis(A, C) + dis(B, D) + dis(C, D);
}
int main() {
scanf("%lf%lf%lf", &a, &b, &c);
A.get();
B.get();
deal();
for (int i = 0; i < 4; ++i) ret = min(ret, ans[i]);
printf("%.10lf\n", ret);
return 0;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
You are given two integers a and b. You may perform any number of operations on them (possibly zero).
During each operation you should choose any positive integer x and set a := a - x, b := b - 2x or a := a - 2x, b := b - x. Note that you may choose different values of x in different operations.
Is it possible to make a and b equal to 0 simultaneously?
Your program should answer t independent test cases.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
Then the test cases follow, each test case is represented by one line containing two integers a and b for this test case (0 ≤ a, b ≤ 10^9).
Output
For each test case print the answer to it — YES if it is possible to make a and b equal to 0 simultaneously, and NO otherwise.
You may print every letter in any case you want (so, for example, the strings yEs, yes, Yes and YES will all be recognized as positive answer).
Example
Input
3
6 9
1 1
1 2
Output
YES
NO
YES
Note
In the first test case of the example two operations can be used to make both a and b equal to zero:
1. choose x = 4 and set a := a - x, b := b - 2x. Then a = 6 - 4 = 2, b = 9 - 8 = 1;
2. choose x = 1 and set a := a - 2x, b := b - x. Then a = 2 - 2 = 0, b = 1 - 1 = 0.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 2;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int ko;
cin >> ko;
long long a, b;
while (ko--) {
cin >> a >> b;
if (a > b) swap(a, b);
if ((2 * a) < b) {
cout << "NO" << endl;
} else if ((a + b) % 3 == 0) {
cout << "YES" << endl;
} else
cout << "NO" << endl;
}
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
Petya and Vasya are competing with each other in a new interesting game as they always do.
At the beginning of the game Petya has to come up with an array of N positive integers. Sum of all elements in his array should be equal to S. Then Petya has to select an integer K such that 0 ≤ K ≤ S.
In order to win, Vasya has to find a non-empty subarray in Petya's array such that the sum of all selected elements equals to either K or S - K. Otherwise Vasya loses.
You are given integers N and S. You should determine if Petya can win, considering Vasya plays optimally. If Petya can win, help him to do that.
Input
The first line contains two integers N and S (1 ≤ N ≤ S ≤ 10^{6}) — the required length of the array and the required sum of its elements.
Output
If Petya can win, print "YES" (without quotes) in the first line. Then print Petya's array in the second line. The array should contain N positive integers with sum equal to S. In the third line print K. If there are many correct answers, you can print any of them.
If Petya can't win, print "NO" (without quotes).
You can print each letter in any register (lowercase or uppercase).
Examples
Input
1 4
Output
YES
4
2
Input
3 4
Output
NO
Input
3 8
Output
YES
2 1 5
4
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, s;
cin >> n >> s;
int a[n + 1];
int cnt = 0;
for (int i = 1; i < n; ++i) {
a[i] = 1;
cnt++;
}
a[n] = s - cnt;
s -= cnt;
if (s - cnt < 2) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
for (int i = 1; i <= n; ++i) cout << a[i] << ' ';
cout << endl;
cout << (cnt + 1) << endl;
}
return 0;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
There is an integer sequence A of length N whose values are unknown.
Given is an integer sequence B of length N-1 which is known to satisfy the following:
B_i \geq \max(A_i, A_{i+1})
Find the maximum possible sum of the elements of A.
Constraints
* All values in input are integers.
* 2 \leq N \leq 100
* 0 \leq B_i \leq 10^5
Input
Input is given from Standard Input in the following format:
N
B_1 B_2 ... B_{N-1}
Output
Print the maximum possible sum of the elements of A.
Examples
Input
3
2 5
Output
9
Input
2
3
Output
6
Input
6
0 153 10 10 23
Output
53
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,ans=0;;
cin>>n;
vector<int> b(n);
for(int i=0;i<n-1;i++){
cin>>b[i];
}
b[n-1]=b[n-2];
ans+=b[0];
for(int i=0;i<n-1;i++){
ans+=min(b[i],b[i+1]);
}
cout<<ans<<endl;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
Let's solve the geometric problem
Mr. A is still solving geometric problems today. It is important to be aware of floating point errors when solving geometric problems.
Floating-point error is the error caused by the rounding that occurs when representing a number in binary finite decimal numbers. For example, 0.1 in decimal is an infinite decimal number of 0.00011001100110011 ... in binary, but an error occurs when rounding this to a finite number of digits.
Positive integers p and q are given in decimal notation. Find the b-ary system (b is an integer greater than or equal to 2) so that the rational number p / q can be expressed as a decimal number with a finite number of digits. If there are more than one, output the smallest one.
Constraints
* 0 <p <q <10 ^ 9
Input Format
Input is given from standard input in the following format.
p q
Output Format
Print the answer in one line.
Sample Input 1
1 2
Sample Output 1
2
1/2 is binary 0.1
Sample Input 2
21 30
Sample Output 2
Ten
21/30 is 0.7 in decimal
Example
Input
1 2
Output
2
### Response
```cpp
#include <stdio.h>
#include <cmath>
#include <algorithm>
#include <stack>
#include <queue>
#include <vector>
typedef long long int ll;
#define BIG_NUM 2000000000
using namespace std;
int calc(int x,int y){
if(y == 0){
return x;
}else{
return calc(y,x%y);
}
}
int main(){
int p,q,common,limit;
scanf("%d %d",&p,&q);
common = calc(p,q);
p /= common;
q /= common;
limit = sqrt(q);
int ans = 1;
for(int i = 2; i <= limit; i++){
if(q%i == 0){
ans *= i;
while(q % i == 0)q /= i;
}
}
ans *= q;
printf("%d\n",ans);
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
We will call a string that can be obtained by concatenating two equal strings an even string. For example, `xyzxyz` and `aaaaaa` are even, while `ababab` and `xyzxy` are not.
For a non-empty string S, we will define f(S) as the shortest even string that can be obtained by appending one or more characters to the end of S. For example, f(`abaaba`)=`abaababaab`. It can be shown that f(S) is uniquely determined for a non-empty string S.
You are given an even string S consisting of lowercase English letters. For each letter in the lowercase English alphabet, find the number of its occurrences from the l-th character through the r-th character of f^{10^{100}} (S).
Here, f^{10^{100}} (S) is the string f(f(f( ... f(S) ... ))) obtained by applying f to S 10^{100} times.
Constraints
* 2 \leq |S| \leq 2\times 10^5
* 1 \leq l \leq r \leq 10^{18}
* S is an even string consisting of lowercase English letters.
* l and r are integers.
Input
Input is given from Standard Input in the following format:
S
l r
Output
Print 26 integers in a line with spaces in between. The i-th integer should be the number of the occurrences of the i-th letter in the lowercase English alphabet from the l-th character through the r-th character of f^{10^{100}} (S).
Examples
Input
abaaba
6 10
Output
3 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
Input
xx
1 1000000000000000000
Output
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1000000000000000000 0 0
Input
vgxgpuamkvgxgvgxgpuamkvgxg
1 1000000000000000000
Output
87167725689669676 0 0 0 0 0 282080685775825810 0 0 0 87167725689669676 0 87167725689669676 0 0 87167725689669676 0 0 0 0 87167725689669676 141040342887912905 0 141040342887912905 0 0
### Response
```cpp
// luogu-judger-enable-o2
#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<cmath>
#define maxn 200010
using namespace std;
typedef long long ll;
char s[maxn];
ll L,R;
int n,T;
int fail[maxn];
void get_fail()
{
fail[1]=0;
for(int i=2;i<=n;i++)
{
int j=fail[i-1];
while(j&&s[j+1]!=s[i]) j=fail[j];
if(s[j+1]==s[i]) j++;
fail[i]=j;
}
T=n-fail[n];
}
int sum[maxn][30];
ll calc(ll x,int c)
{
if(x<=n) return sum[x][c];
if(x<=2*n) return sum[n][c]+sum[x-n][c];
ll f1=sum[n][c],f2=sum[n][c]+sum[T][c],l1=n,l2=n+T;
while(x>l1+l2)
{
ll tmp=f2;
f2+=f1;f1=tmp;
tmp=l2;
l2+=l1;l1=tmp;
}
return f2+calc(x-l2,c);
}
int main()
{
scanf("%s",s+1);
cin>>L>>R;
n=strlen(s+1)/2;
get_fail();
for(int i=1;i<=n;i++)
{
memcpy(sum[i],sum[i-1],sizeof(sum[i-1]));
sum[i][s[i]-'a']++;
}
for(int i=0;i<26;i++) printf("%lld ",calc(R,i)-calc(L-1,i));
puts("");
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
The R1 company wants to hold a web search championship. There were n computers given for the competition, each of them is connected to the Internet. The organizers believe that the data transfer speed directly affects the result. The higher the speed of the Internet is, the faster the participant will find the necessary information. Therefore, before the competition started, each computer had its maximum possible data transfer speed measured. On the i-th computer it was ai kilobits per second.
There will be k participants competing in the championship, each should get a separate computer. The organizing company does not want any of the participants to have an advantage over the others, so they want to provide the same data transfer speed to each participant's computer. Also, the organizers want to create the most comfortable conditions for the participants, so the data transfer speed on the participants' computers should be as large as possible.
The network settings of the R1 company has a special option that lets you to cut the initial maximum data transfer speed of any computer to any lower speed. How should the R1 company configure the network using the described option so that at least k of n computers had the same data transfer speed and the data transfer speed on these computers was as large as possible?
Input
The first line contains two space-separated integers n and k (1 ≤ k ≤ n ≤ 100) — the number of computers and the number of participants, respectively. In the second line you have a space-separated sequence consisting of n integers: a1, a2, ..., an (16 ≤ ai ≤ 32768); number ai denotes the maximum data transfer speed on the i-th computer.
Output
Print a single integer — the maximum Internet speed value. It is guaranteed that the answer to the problem is always an integer.
Examples
Input
3 2
40 20 30
Output
30
Input
6 4
100 20 40 20 50 50
Output
40
Note
In the first test case the organizers can cut the first computer's speed to 30 kilobits. Then two computers (the first and the third one) will have the same speed of 30 kilobits. They should be used as the participants' computers. This answer is optimal.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 1e9 + 7;
const long long int INF = 10000000;
const long long int MAX_N = 1e6 + 2;
void solve() {
int n, k;
cin >> n >> k;
vector<int> v(n);
for (int i = 0; i < n; ++i) cin >> v[i];
sort((v).begin(), (v).end());
cout << v[n - k];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int t = 1;
while (t--) solve();
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
While Duff was resting in the beach, she accidentally found a strange array b0, b1, ..., bl - 1 consisting of l positive integers. This array was strange because it was extremely long, but there was another (maybe shorter) array, a0, ..., an - 1 that b can be build from a with formula: bi = ai mod n where a mod b denoted the remainder of dividing a by b.
<image>
Duff is so curious, she wants to know the number of subsequences of b like bi1, bi2, ..., bix (0 ≤ i1 < i2 < ... < ix < l), such that:
* 1 ≤ x ≤ k
* For each 1 ≤ j ≤ x - 1, <image>
* For each 1 ≤ j ≤ x - 1, bij ≤ bij + 1. i.e this subsequence is non-decreasing.
Since this number can be very large, she want to know it modulo 109 + 7.
Duff is not a programmer, and Malek is unavailable at the moment. So she asked for your help. Please tell her this number.
Input
The first line of input contains three integers, n, l and k (1 ≤ n, k, n × k ≤ 106 and 1 ≤ l ≤ 1018).
The second line contains n space separated integers, a0, a1, ..., an - 1 (1 ≤ ai ≤ 109 for each 0 ≤ i ≤ n - 1).
Output
Print the answer modulo 1 000 000 007 in one line.
Examples
Input
3 5 3
5 9 1
Output
10
Input
5 10 3
1 2 3 4 5
Output
25
Note
In the first sample case, <image>. So all such sequences are: <image>, <image>, <image>, <image>, <image>, <image>, <image>, <image>, <image> and <image>.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 6;
const int MAXD = 1e6 + 5;
const int mod = 1e9 + 7;
inline void add_mod(int &a, int b) {
a += b;
if (a >= mod) a -= mod;
}
int a[MAXN];
struct Node {
int x, id;
} b[MAXN];
inline bool cmp(const Node &p, const Node &q) { return p.x < q.x; }
struct Number {
int x, cnt, ecnt;
} c[MAXN];
vector<int> f[MAXD];
int main(void) {
int n, d;
long long l;
cin >> n >> l >> d;
int nn = l % n;
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 1; i <= n; ++i) b[i] = (Node){a[i], i};
sort(b + 1, b + n + 1, cmp);
int m = 0;
for (int i = 1, j = 1; j <= n; i = j) {
c[++m].x = b[i].x;
while (j <= n && b[j].x == b[i].x) {
if (b[j].id <= nn) ++c[m].ecnt;
++j;
}
c[m].cnt = j - i;
}
for (int i = 0; i <= d; ++i) f[i].resize(m + 5);
for (int i = 1; i <= m; ++i) f[0][i] = 1;
int ans = 0;
for (int i = 1; i <= d; ++i) {
for (int j = 1; j <= m; ++j)
f[i][j] = (long long)f[i - 1][j] * c[j].cnt % mod;
for (int j = 1; j <= m; ++j) add_mod(f[i][j], f[i][j - 1]);
if (i - 1 > l / n) continue;
add_mod(ans, (long long)(l / n - i + 1) % mod * f[i][m] % mod);
for (int j = 1; j <= m; ++j)
add_mod(ans, (long long)f[i - 1][j] * c[j].ecnt % mod);
}
printf("%d", ans);
return 0;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
There are N lines in the xy-plane. The i-th line is represented by A_ix+B_iy=C_i. Any two lines among the N+2 lines, the above N lines plus the x-axis and y-axis, cross each other at exactly one point.
For each pair 1 \leq i < j \leq N, there is a car at the cross point of the i-th and j-th lines. Even where three or more lines intersect at a point, a car is individually placed for each pair of lines. That is, there will be k(k-1)/2 cars placed at the intersection of k lines.
Those cars are already very old, and can only be moved parallel to the x-axis or y-axis.
Takahashi will hold an exhibition of antique cars at a place on the xy-plane. In order to avoid damaging the half-broken cars too much, he will select the place of the exhibition so that the total distance covered will be minimized when all the cars are moved to the place. If such a place is not uniquely determined, among the places that satisfy the condition above, the place with the minimum x-coordinate will be selected. If the place is still not uniquely determined, among the places that satisfy the two conditions above, the place with the minimum y-coordinate will be selected.
Find the place of the exhibition that will be selected.
Constraints
* 2 \leq N \leq 4 × 10^4
* 1 \leq |A_i|,|B_i| \leq 10^4(1 \leq i \leq N)
* 0 \leq |C_i| \leq 10^4(1 \leq i \leq N)
* No two given lines are parallel.
* All input values are integers.
Inputs
Input is given from Standard Input in the following format:
N
A_1 B_1 C_1
:
A_N B_N C_N
Outputs
Print the x-coordinate and y-coordinate of the place of the exhibition that will be selected, in this order, with a space in between. The output will be judged as correct when the absolute or relative error is at most 10^{-9}.
Examples
Input
3
1 1 1
2 -1 2
-1 2 2
Output
1.000000000000000 1.000000000000000
Input
4
1 1 2
1 -1 0
3 -1 -2
1 -3 4
Output
-1.000000000000000 -1.000000000000000
Input
7
1 7 8
-2 4 9
3 -8 -5
9 2 -14
6 7 5
-8 -9 3
3 8 10
Output
-1.722222222222222 1.325000000000000
### Response
```cpp
#include <bits/stdc++.h>
#if MYDEBUG
#include "lib/cp_debug.hpp"
#else
#define DBG(...) ;
#endif
#if __cplusplus <= 201402L
template <typename T>
T gcd(T a, T b) { return ((a % b == 0) ? b : gcd(b, a % b)); }
template <typename T>
T lcm(T a, T b) { return a / gcd(a, b) * b; }
#endif
using LL = long long;
constexpr LL LINF = 334ll << 53;
constexpr int INF = 15 << 26;
constexpr LL MOD = 1E9 + 7;
//https://beta.atcoder.jp/contests/tenka1-2017/tasks/tenka1_2017_e
namespace Problem {
using namespace std;
struct Line {
double a, b, c;
};
struct FindX {
double operator()(Line &l, double y) {
return (l.c - l.b * y) / l.a;
//return (b.b * a.c - a.b * b.c) / (b.b * a.a - a.b * b.a);
}
};
struct FindY {
double operator()(Line &l, double x) {
return (l.c - l.a * x) / l.b;
//return (-b.a * a.c + a.a * b.c) / (b.b * a.a - a.b * b.a);
}
};
struct sortByMinX {
bool operator()(Line &a, Line &b) { return -a.a / a.b > -b.a / b.b; }
};
struct sortByMinY {
bool operator()(Line &a, Line &b) { return -a.b / a.a > -b.b / b.a; }
};
template <typename T>
struct BIT {
vector<T> bit;
int size;
BIT(int _size) : bit(vector<T>(_size + 1, 0)), size(_size) {}
void add(int index, T value) {
for (int i = index + 1; i <= size; i += (i & -i)) bit[i] += value;
}
T sum(int a, int b) { //sum of[a,b)
return sum(b) - sum(a);
}
T sum(int a) { // sum of[0,a) = sum of bit[0]~bit[a]
T ret = 0;
for (int i = a; i > 0; i -= (i & -i)) ret += bit[i];
return ret;
}
};
class Solver {
public:
int n;
vector<Line> line;
Solver(LL n) : n(n), line(n){};
void solve() {
for (int i = 0; i < n; ++i) {
cin >> line[i].a >> line[i].b >> line[i].c;
}
cout << binarySearch<FindY, sortByMinX>() << ' ' << binarySearch<FindX, sortByMinY>() << endl;
}
template <class Calc, class S>
double binarySearch() {
Calc op;
sort(line.rbegin(), line.rend(), S());
double lb = -1e9, ub = 1e9;
for (int i = 0; i < 80; ++i) {
double mid = (lb + ub) / 2;
vector<pair<double, int>> coord;
for (int j = 0; j < n; ++j) {
coord.emplace_back(op(line[j], mid), j);
}
sort(coord.begin(), coord.end());
BIT<int> bit(n);
int cnt = 0;
for (int j = 0; j < n; ++j) {
cnt += bit.sum(coord[j].second);
bit.add(coord[j].second, 1);
}
DBG(mid, coord, cnt)
if (cnt >= (n * (n - 1) / 2 + 1) / 2) {
ub = mid;
} else {
lb = mid;
}
}
return ub;
}
};
} // namespace Problem
int main() {
std::cin.tie(0);
std::ios_base::sync_with_stdio(false);
std::cout << std::fixed << std::setprecision(12);
long long n = 0;
std::cin >> n;
Problem::Solver sol(n);
sol.solve();
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
While Grisha was celebrating New Year with Ded Moroz, Misha gifted Sasha a small rectangular pond of size n × m, divided into cells of size 1 × 1, inhabited by tiny evil fishes (no more than one fish per cell, otherwise they'll strife!).
The gift bundle also includes a square scoop of size r × r, designed for fishing. If the lower-left corner of the scoop-net is located at cell (x, y), all fishes inside the square (x, y)...(x + r - 1, y + r - 1) get caught. Note that the scoop-net should lie completely inside the pond when used.
Unfortunately, Sasha is not that skilled in fishing and hence throws the scoop randomly. In order to not frustrate Sasha, Misha decided to release k fishes into the empty pond in such a way that the expected value of the number of caught fishes is as high as possible. Help Misha! In other words, put k fishes in the pond into distinct cells in such a way that when the scoop-net is placed into a random position among (n - r + 1)·(m - r + 1) possible positions, the average number of caught fishes is as high as possible.
Input
The only line contains four integers n, m, r, k (1 ≤ n, m ≤ 105, 1 ≤ r ≤ min(n, m), 1 ≤ k ≤ min(n·m, 105)).
Output
Print a single number — the maximum possible expected number of caught fishes.
You answer is considered correct, is its absolute or relative error does not exceed 10 - 9. Namely, let your answer be a, and the jury's answer be b. Your answer is considered correct, if <image>.
Examples
Input
3 3 2 3
Output
2.0000000000
Input
12 17 9 40
Output
32.8333333333
Note
In the first example you can put the fishes in cells (2, 1), (2, 2), (2, 3). In this case, for any of four possible positions of the scoop-net (highlighted with light green), the number of fishes inside is equal to two, and so is the expected value.
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T& x) {
x = 0;
char c;
int sign = 1;
do {
c = getchar();
if (c == '-') sign = -1;
} while (!isdigit(c));
do {
x = x * 10 + c - '0';
c = getchar();
} while (isdigit(c));
x *= sign;
}
const int N = 100;
int n, m, r;
long long k;
long long f[100005], g[100005];
long long F[100005], G[100005];
priority_queue<pair<long long, pair<long long, long long> > > q;
map<long long, long long> mp[100005];
int main() {
scanf("%d%d%d%I64d", &n, &m, &r, &k);
long long m1 = 0, m2 = 0;
for (int i = 1; i <= n; i++) {
f[i] = min(min(r, n - r + 1), min(i, n - i + 1));
F[f[i]]++;
m1 = max(m1, f[i]);
}
for (int i = 1; i <= m; i++) {
g[i] = min(min(m - r + 1, r), min(i, m - i + 1));
G[g[i]]++;
m2 = max(m2, g[i]);
}
double ans = 0;
long long cnt = 0;
q.push(make_pair(m1 * m2, make_pair(m1, m2)));
while (cnt < k) {
pair<long long, pair<long long, long long> > tmp = q.top();
while (mp[tmp.second.first].count(tmp.second.second))
q.pop(), tmp = q.top();
q.pop();
long long cc = F[tmp.second.first] * G[tmp.second.second];
mp[tmp.second.first][tmp.second.second] = 1;
if (cc >= k - cnt) cc = k - cnt;
ans = ans + tmp.first * cc;
cnt = cnt + cc;
m1 = tmp.second.first, m2 = tmp.second.second;
q.push(make_pair((m1 - 1) * m2, make_pair(m1 - 1, m2)));
q.push(make_pair(m1 * (m2 - 1), make_pair(m1, m2 - 1)));
}
ans = ans / double(n - r + 1);
ans = ans / double(m - r + 1);
printf("%.12lf", ans);
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
There are N stones, numbered 1, 2, \ldots, N. For each i (1 \leq i \leq N), the height of Stone i is h_i. Here, h_1 < h_2 < \cdots < h_N holds.
There is a frog who is initially on Stone 1. He will repeat the following action some number of times to reach Stone N:
* If the frog is currently on Stone i, jump to one of the following: Stone i + 1, i + 2, \ldots, N. Here, a cost of (h_j - h_i)^2 + C is incurred, where j is the stone to land on.
Find the minimum possible total cost incurred before the frog reaches Stone N.
Constraints
* All values in input are integers.
* 2 \leq N \leq 2 \times 10^5
* 1 \leq C \leq 10^{12}
* 1 \leq h_1 < h_2 < \cdots < h_N \leq 10^6
Input
Input is given from Standard Input in the following format:
N C
h_1 h_2 \ldots h_N
Output
Print the minimum possible total cost incurred.
Examples
Input
5 6
1 2 3 4 5
Output
20
Input
2 1000000000000
500000 1000000
Output
1250000000000
Input
8 5
1 3 4 5 10 11 12 13
Output
62
### Response
```cpp
#include <iostream>
#include <deque>
using namespace std;
int main() {
ios_base::sync_with_stdio(false); cin.tie(0);
int n; long long c; cin >> n >> c;
deque<pair<long long, long long> > hull;
long long h, dp[n]; cin >> h;
hull.push_back(make_pair(-2 * h, (dp[0] = 0) + h * h));
for (int i = 1; i < n; i++) {
cin >> h;
while (hull.size() >= 2 && hull[0].first * h + hull[0].second >= hull[1].first * h + hull[1].second) hull.pop_front();
dp[i] = hull[0].first * h + hull[0].second + h * h + c;
hull.push_back(make_pair(-2 * h, dp[i] + h * h));
while (hull.size() >= 3 && (hull[hull.size() - 2].second - hull[hull.size() - 3].second) * (hull[hull.size() - 2].first - hull[hull.size() - 1].first) >= (hull[hull.size() - 1].second - hull[hull.size() - 2].second) * (hull[hull.size() - 3].first - hull[hull.size() - 2].first)) {
hull[hull.size() - 2] = hull[hull.size() - 1];
hull.pop_back();
}
}
cout << dp[n - 1];
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Problem
If you bring an empty bottle of $ a $ milk, you can exchange it for a new bottle of $ b $ milk.
How many bottles of milk can Mr. Kawabayashi, who initially has a bottle of $ x $ milk, drink? Output the remainder after dividing by $ 1000000007 $.
Constraints
The input satisfies the following conditions.
* $ 1 \ leq a \ leq 10 ^ {15} $
* $ 0 \ leq b \ lt a $
* $ 0 \ leq x \ leq 10 ^ {15} $
Input
The input is given in the following format.
$ a $ $ b $ $ x $
Three integers $ a $, $ b $, $ x $ are given, separated by spaces.
Output
Print the answer on one line.
Examples
Input
3 1 5
Output
7
Input
3 2 5
Output
11
Input
82 69 64
Output
64
Input
316250877917604 316250877917599 681260158257385
Output
62687552
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int M = 1000000007;
int main() {
long long a,b,x;
cin >> a >> b >> x;
if (x < a) {
cout << x % M << "\n";
}
else {
cout << (((x - a) / (a - b) + 1) % M * (b % M) % M + x) % M << '\n';
}
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Let's define a function f(p) on a permutation p as follows. Let g_i be the [greatest common divisor (GCD)](https://en.wikipedia.org/wiki/Greatest_common_divisor) of elements p_1, p_2, ..., p_i (in other words, it is the GCD of the prefix of length i). Then f(p) is the number of distinct elements among g_1, g_2, ..., g_n.
Let f_{max}(n) be the maximum value of f(p) among all permutations p of integers 1, 2, ..., n.
Given an integers n, count the number of permutations p of integers 1, 2, ..., n, such that f(p) is equal to f_{max}(n). Since the answer may be large, print the remainder of its division by 1000 000 007 = 10^9 + 7.
Input
The only line contains the integer n (2 ≤ n ≤ 10^6) — the length of the permutations.
Output
The only line should contain your answer modulo 10^9+7.
Examples
Input
2
Output
1
Input
3
Output
4
Input
6
Output
120
Note
Consider the second example: these are the permutations of length 3:
* [1,2,3], f(p)=1.
* [1,3,2], f(p)=1.
* [2,1,3], f(p)=2.
* [2,3,1], f(p)=2.
* [3,1,2], f(p)=2.
* [3,2,1], f(p)=2.
The maximum value f_{max}(3) = 2, and there are 4 permutations p such that f(p)=2.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
int add(long long a, long long b) { return (a + b) % mod; }
int mul(long long a, long long b) { return (a * b) % mod; }
int n;
int dp[1000001][21][2];
int p2[30];
int pow2(int x) {
if (p2[x] != 0) return p2[x];
p2[x] = (1 << x);
return p2[x];
}
int p3[2];
int pow3(int x) {
if (p3[x] != 0) return p3[x];
if (x == 0) return 1;
p3[x] = pow3(x - 1) * 3;
return p3[x];
}
int main(void) {
cin >> n;
int x = log2(n);
dp[1][x][0] = 1;
if ((1 << (x - 1)) * 3 <= n) dp[1][x - 1][1] = 1;
for (int i = 1; i <= n - 1; i++) {
for (int j = 0; j < 21; j++) {
for (int k = 0; k < 2; k++) {
if (dp[i][j][k] == 0) continue;
int f = n / pow2(j) / pow3(k);
dp[i + 1][j][k] = add(dp[i + 1][j][k], mul(dp[i][j][k], (f - i)));
if (j > 0) {
int ff = n / pow2(j - 1) / pow3(k);
dp[i + 1][j - 1][k] =
add(dp[i + 1][j - 1][k], mul(dp[i][j][k], (ff - f)));
}
if (k > 0) {
int ff = n / pow2(j) / pow3(k - 1);
dp[i + 1][j][k - 1] =
add(dp[i + 1][j][k - 1], mul(dp[i][j][k], (ff - f)));
}
}
}
}
cout << dp[n][0][0] << endl;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
Dasha decided to have a rest after solving the problem. She had been ready to start her favourite activity — origami, but remembered the puzzle that she could not solve.
<image>
The tree is a non-oriented connected graph without cycles. In particular, there always are n - 1 edges in a tree with n vertices.
The puzzle is to position the vertices at the points of the Cartesian plane with integral coordinates, so that the segments between the vertices connected by edges are parallel to the coordinate axes. Also, the intersection of segments is allowed only at their ends. Distinct vertices should be placed at different points.
Help Dasha to find any suitable way to position the tree vertices on the plane.
It is guaranteed that if it is possible to position the tree vertices on the plane without violating the condition which is given above, then you can do it by using points with integral coordinates which don't exceed 1018 in absolute value.
Input
The first line contains single integer n (1 ≤ n ≤ 30) — the number of vertices in the tree.
Each of next n - 1 lines contains two integers ui, vi (1 ≤ ui, vi ≤ n) that mean that the i-th edge of the tree connects vertices ui and vi.
It is guaranteed that the described graph is a tree.
Output
If the puzzle doesn't have a solution then in the only line print "NO".
Otherwise, the first line should contain "YES". The next n lines should contain the pair of integers xi, yi (|xi|, |yi| ≤ 1018) — the coordinates of the point which corresponds to the i-th vertex of the tree.
If there are several solutions, print any of them.
Examples
Input
7
1 2
1 3
2 4
2 5
3 6
3 7
Output
YES
0 0
1 0
0 1
2 0
1 -1
-1 1
0 2
Input
6
1 2
2 3
2 4
2 5
2 6
Output
NO
Input
4
1 2
2 3
3 4
Output
YES
3 3
4 3
5 3
6 3
Note
In the first sample one of the possible positions of tree is: <image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct Node {
long long x, y;
Node() {}
Node(long long a, long long b) {
x = a;
y = b;
}
};
vector<int> eage[35];
int dir[4][2] = {-1, 0, 0, 1, 1, 0, 0, -1};
int deg[35];
int vis[35];
int n;
long long len = 1 << 30;
Node coor[35];
void dfs(int p, int d) {
int di = 0;
for (int i = 0; i < eage[p].size(); i++) {
if (vis[eage[p][i]] == 0) {
if (di == d) di = (di + 1) % 4;
vis[eage[p][i]] = 1;
coor[eage[p][i]].x = coor[p].x + dir[di][0] * len;
coor[eage[p][i]].y = coor[p].y + dir[di][1] * len;
len = len / 2;
dfs(eage[p][i], (di + 2) % 4);
di = (di + 1) % 4;
}
}
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n - 1; i++) {
int a, b;
scanf("%d%d", &a, &b);
eage[a].push_back(b);
eage[b].push_back(a);
deg[a]++;
deg[b]++;
}
for (int i = 1; i <= n; i++)
if (deg[i] > 4) {
printf("NO\n");
return 0;
}
vis[1] = 1;
dfs(1, -10);
printf("YES\n");
for (int i = 1; i <= n; i++) printf("%I64d %I64d\n", coor[i].x, coor[i].y);
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
Koto Municipal Subway
Koto Municipal Subway
Koto City is a famous city whose roads are in a grid pattern, as shown in the figure below. The roads extending from north to south and the roads extending from east to west are lined up at intervals of 1 km each. Let Koto station at the southwestern intersection of Koto city be (0, 0), and mark x km east and y km north from it as (x, y) (0 ≤ x, y). ).
<image>
In anticipation of an increase in tourists due to the Olympic Games to be held five years later, the city has decided to build a new subway line starting from Koto station. Currently, we are planning to lay a rail to Shin-Koto station, which will be newly constructed as the next station after Koto station. The rail will be laid straight from Koto station to Shin-Koto station. Therefore, when the location of Shin-Koto station is (x, y), the length of the rail is √ (x2 + y2). The cost of laying the rail is the same as the length of the laid rail. Even if the rail length is a decimal number such as 1.5km, the cost is also 1.5.
The location (x, y) of Shin-Koto station has not been decided yet, and we plan to make it a location that meets the following conditions.
* It is an intersection. That is, x and y are integers, respectively.
* The shortest distance walked along the road from Koto station is exactly D. That is, x + y = D is satisfied.
Among the above two conditions, select the location of Shin-Koto station so that the difference between the rail budget E and the rail cost set by the city | √ (x2 + y2) --E | is minimized. Here, | A | represents the absolute value of A. Your job is to create a program that outputs the difference between the cost and budget for laying rails when the Shin-Koto station was constructed as described above.
Input
The input consists of multiple data sets, and the number of data sets contained in one input is 100 or less. The format of each data set is as follows.
> D E
D (1 ≤ D ≤ 100) is an integer that represents the shortest distance when walking along the road from Koto station to Shin-Koto station. E (1 ≤ E ≤ 100) is an integer representing the budget for rail construction.
The end of the input is indicated by a line of two zeros separated by a blank.
Output
For each data set, output the difference between the cost and budget when laying the rail so as to satisfy the problem condition in one line. The answer must have an absolute error greater than 10-3. Note that if you do not output a line break at the end of each line, or if you output unnecessary characters, it will be judged as an incorrect answer.
Sample Input
twenty one
7 5
7 6
7 7
76 5
8 41
0 0
Output for Sample Input
0.4142135624
0
0.0827625303
0
48.7401153702
33
Hint
In the first data set, as shown in the figure below, an intersection 2 km along the road from Koto station is a candidate for a place to build Shin-Koto station.
<image>
When Shin-Koto station is constructed at each intersection, the difference between the cost for laying the rail and budget 1 is as follows.
* (2, 0): | √ (22 + 02) --1 | = 1.0
* (1, 1): | √ (12 + 12) --1 | = 0.4142135623 ...
* (0, 2): | √ (02 + 22) --1 | = 1.0
Therefore, the difference between the cost and the budget is minimized when the construction is done in (1, 1).
Example
Input
2 1
7 5
7 6
7 7
76 5
8 41
0 0
Output
0.4142135624
0
0.0827625303
0
48.7401153702
33
### Response
```cpp
#include <cmath>
#include <iostream>
using namespace std;
int main() {
while (true) {
int D, E;
cin >> D >> E;
if (D == 0) {
break;
}
double minerr = abs(D - E);
for (int x = 0; x <= D / 2; x++) {
int y = D - x;
double err = abs(sqrt(x * x + y * y) - E);
if (err < minerr) {
minerr = err;
}
}
cout << minerr << endl;
}
return 0;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
Lee is used to finish his stories in a stylish way, this time he barely failed it, but Ice Bear came and helped him. Lee is so grateful for it, so he decided to show Ice Bear his new game called "Critic"...
The game is a one versus one game. It has t rounds, each round has two integers s_i and e_i (which are determined and are known before the game begins, s_i and e_i may differ from round to round). The integer s_i is written on the board at the beginning of the corresponding round.
The players will take turns. Each player will erase the number on the board (let's say it was a) and will choose to write either 2 ⋅ a or a + 1 instead. Whoever writes a number strictly greater than e_i loses that round and the other one wins that round.
Now Lee wants to play "Critic" against Ice Bear, for each round he has chosen the round's s_i and e_i in advance. Lee will start the first round, the loser of each round will start the next round.
The winner of the last round is the winner of the game, and the loser of the last round is the loser of the game.
Determine if Lee can be the winner independent of Ice Bear's moves or not. Also, determine if Lee can be the loser independent of Ice Bear's moves or not.
Input
The first line contains the integer t (1 ≤ t ≤ 10^5) — the number of rounds the game has.
Then t lines follow, each contains two integers s_i and e_i (1 ≤ s_i ≤ e_i ≤ 10^{18}) — the i-th round's information.
The rounds are played in the same order as given in input, s_i and e_i for all rounds are known to everyone before the game starts.
Output
Print two integers.
The first one should be 1 if Lee can be the winner independent of Ice Bear's moves, and 0 otherwise.
The second one should be 1 if Lee can be the loser independent of Ice Bear's moves, and 0 otherwise.
Examples
Input
3
5 8
1 4
3 10
Output
1 1
Input
4
1 2
2 3
3 4
4 5
Output
0 0
Input
1
1 1
Output
0 1
Input
2
1 9
4 5
Output
0 0
Input
2
1 2
2 8
Output
1 0
Input
6
216986951114298167 235031205335543871
148302405431848579 455670351549314242
506251128322958430 575521452907339082
1 768614336404564650
189336074809158272 622104412002885672
588320087414024192 662540324268197150
Output
1 0
Note
Remember, whoever writes an integer greater than e_i loses.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long s[100100], e[100100];
int T;
bool f(long long a, long long b, bool c) {
if (!c) {
if (a > b / 2) {
return true;
} else {
b = b / 2;
}
}
while (true) {
if (b % 2) {
return (1 - a) % 2;
} else {
if (a > b / 2) {
return a % 2;
} else {
b = b / 2;
if (a > b / 2) {
return true;
}
b = b / 2;
}
}
}
}
bool solve(bool goal) {
for (int i = T - 1; i >= 0; i--) {
goal = !f(s[i], e[i], goal);
}
return !goal;
}
int main() {
cin >> T;
for (int i = 0; i < T; i++) {
cin >> s[i] >> e[i];
}
cout << solve(true) << " " << solve(false) << endl;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
You are at the top left cell (1, 1) of an n × m labyrinth. Your goal is to get to the bottom right cell (n, m). You can only move right or down, one cell per step. Moving right from a cell (x, y) takes you to the cell (x, y + 1), while moving down takes you to the cell (x + 1, y).
Some cells of the labyrinth contain rocks. When you move to a cell with rock, the rock is pushed to the next cell in the direction you're moving. If the next cell contains a rock, it gets pushed further, and so on.
The labyrinth is surrounded by impenetrable walls, thus any move that would put you or any rock outside of the labyrinth is illegal.
Count the number of different legal paths you can take from the start to the goal modulo 10^9 + 7. Two paths are considered different if there is at least one cell that is visited in one path, but not visited in the other.
Input
The first line contains two integers n, m — dimensions of the labyrinth (1 ≤ n, m ≤ 2000).
Next n lines describe the labyrinth. Each of these lines contains m characters. The j-th character of the i-th of these lines is equal to "R" if the cell (i, j) contains a rock, or "." if the cell (i, j) is empty.
It is guaranteed that the starting cell (1, 1) is empty.
Output
Print a single integer — the number of different legal paths from (1, 1) to (n, m) modulo 10^9 + 7.
Examples
Input
1 1
.
Output
1
Input
2 3
...
..R
Output
0
Input
4 4
...R
.RR.
.RR.
R...
Output
4
Note
In the first sample case we can't (and don't have to) move, hence the only path consists of a single cell (1, 1).
In the second sample case the goal is blocked and is unreachable.
Illustrations for the third sample case can be found here: <https://assets.codeforces.com/rounds/1225/index.html>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 2005, M = 1e9 + 7;
int n, m;
string grid[N];
long long row[N][N], col[N][N];
long long dp[N][N][2];
long long rowdpsum[N][N][2];
long long coldpsum[N][N][2];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> grid[i];
for (int i = n - 1; i >= 0; i--) {
for (int j = m - 1; j >= 0; j--) {
row[i][j] = (grid[i][j] != 'R') + row[i][j + 1];
col[i][j] = (grid[i][j] != 'R') + col[i + 1][j];
}
}
if (grid[n - 1][m - 1] == 'R') {
cout << 0 << endl;
return 0;
}
if (n == 1 && m == 1) {
cout << 1 << endl;
return 0;
}
for (int j = m - 1; j >= 0; j--) {
if (grid[n - 1][j] == 'R') break;
coldpsum[n - 1][j][0] = dp[n - 1][j][0] = 1;
coldpsum[n - 1][j][1] = dp[n - 1][j][1] = 1;
}
for (int j = m - 1; j >= 0; j--) {
rowdpsum[n - 1][j][0] = dp[n - 1][j][0] + rowdpsum[n - 1][j + 1][0];
rowdpsum[n - 1][j][1] = dp[n - 1][j][1] + rowdpsum[n - 1][j + 1][1];
}
for (int i = n - 1; i >= 0; i--) {
if (grid[i][m - 1] == 'R') break;
rowdpsum[i][m - 1][1] = dp[i][m - 1][1] = 1;
rowdpsum[i][m - 1][0] = dp[i][m - 1][0] = 1;
}
for (int i = n - 1; i >= 0; i--) {
coldpsum[i][m - 1][1] = dp[i][m - 1][1] + coldpsum[i + 1][m - 1][1];
coldpsum[i][m - 1][0] = dp[i][m - 1][0] + coldpsum[i + 1][m - 1][0];
}
for (int i = n - 2; i >= 0; i--) {
for (int j = m - 2; j >= 0; j--) {
for (int b = 0; b < 2; b++) {
int nic = col[i + 1][j];
int dan = row[i][j + 1];
if (b && grid[i][j] == 'R') dan--;
if (!b && grid[i][j] == 'R') nic--;
dp[i][j][b] +=
rowdpsum[i + 1][j + 1][0] + M - rowdpsum[i + 1][j + dan + 1][0];
dp[i][j][b] +=
coldpsum[i + 1][j + 1][1] + M - coldpsum[i + nic + 1][j + 1][1];
dp[i][j][b] %= M;
rowdpsum[i][j][b] = (dp[i][j][b] + rowdpsum[i][j + 1][b]) % M;
coldpsum[i][j][b] = (dp[i][j][b] + coldpsum[i + 1][j][b]) % M;
}
}
}
cout << (dp[0][1][1] + dp[1][0][0]) % M << endl;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
Ujan needs some rest from cleaning, so he started playing with infinite sequences. He has two integers n and k. He creates an infinite sequence s by repeating the following steps.
1. Find k smallest distinct positive integers that are not in s. Let's call them u_{1}, u_{2}, …, u_{k} from the smallest to the largest.
2. Append u_{1}, u_{2}, …, u_{k} and ∑_{i=1}^{k} u_{i} to s in this order.
3. Go back to the first step.
Ujan will stop procrastinating when he writes the number n in the sequence s. Help him find the index of n in s. In other words, find the integer x such that s_{x} = n. It's possible to prove that all positive integers are included in s only once.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^{5}), the number of test cases.
Each of the following t lines contains two integers n and k (1 ≤ n ≤ 10^{18}, 2 ≤ k ≤ 10^{6}), the number to be found in the sequence s and the parameter used to create the sequence s.
Output
In each of the t lines, output the answer for the corresponding test case.
Example
Input
2
10 2
40 5
Output
11
12
Note
In the first sample, s = (1, 2, 3, 4, 5, 9, 6, 7, 13, 8, 10, 18, …). 10 is the 11-th number here, so the answer is 11.
In the second sample, s = (1, 2, 3, 4, 5, 15, 6, 7, 8, 9, 10, 40, …).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
namespace cyl {
long long n, k;
long long func(long long n) {
if (n == 0) return 0;
long long ret = n / (k + 1) * k * k + n / (k + 1) - k * (k - 1) / 2;
n /= (k + 1);
if (k & 1) {
int yu = (n - 1) % k + 1;
if (yu <= k / 2) return ret - yu;
if (yu > k / 2 + 2) return ret + k - yu;
if (yu == k / 2 + 1) {
n = (n - k / 2 - 1) / k + 1;
yu = (n - 1) % k + 1;
while (yu == k / 2 + 1) {
n = (n - k / 2 - 1) / k + 1;
yu = (n - 1) % k + 1;
if (yu <= k / 2) return ret - yu;
if (yu > k / 2 + 1) return ret;
n = (n - k / 2 - 1) / k + 1;
yu = (n - 1) % k + 1;
}
if (yu <= k / 2) return ret - k / 2 + yu - 1;
return ret - k / 2 - 1;
} else {
n = (n - k / 2 - 2) / k + 1;
yu = (n - 1) % k + 1;
while (yu == k / 2 + 2) {
n = (n - k / 2 - 2) / k + 1;
yu = (n - 1) % k + 1;
if (yu <= k / 2 + 1) return ret;
if (yu > k / 2 + 2) return ret + k - yu;
n = (n - k / 2 - 2) / k + 1;
yu = (n - 1) % k + 1;
}
if (yu <= k / 2 + 1) return ret + k / 2 - 1;
return ret + yu - k / 2 - 2;
}
} else {
int yu = (n - 1) % k + 1;
while (yu == k / 2 + 1) {
n = (n - k / 2 - 1) / k + 1;
yu = (n - 1) % k + 1;
if (yu <= k / 2) return ret + yu - 1;
if (yu > k / 2 + 1) return ret - k + yu - 1;
n = (n - k / 2 - 1) / k + 1;
yu = (n - 1) % k + 1;
}
if (yu <= k / 2) return ret - yu;
return ret + k - yu;
}
}
int main() {
int T;
scanf("%d", &T);
while (T--) {
scanf("%lld%lld", &n, &k);
long long x = (n + k * (k - 1) / 2) / (k * k + 1);
long long tmp = func(x * (k + 1)), idx = 1e18;
if (tmp == n) {
printf("%lld\n", x * (k + 1));
continue;
} else if (tmp > n)
idx = min(idx, x * (k + 1));
tmp = func((x + 1) * (k + 1));
if (tmp == n) {
printf("%lld\n", (x + 1) * (k + 1));
continue;
} else if (tmp > n)
idx = min(idx, (x + 1) * (k + 1));
tmp = func((x + 2) * (k + 1));
if (tmp == n) {
printf("%lld\n", (x + 2) * (k + 1));
continue;
} else if (tmp > n)
idx = min(idx, (x + 2) * (k + 1));
if (x > 0) {
tmp = func((x - 1) * (k + 1));
if (tmp == n) {
printf("%lld\n", (x - 1) * (k + 1));
continue;
} else if (tmp > n)
idx = min(idx, (x - 1) * (k + 1));
}
idx -= k + 1;
printf("%lld\n", idx + (n - idx) / k * (k + 1) + (n - idx) % k +
((n - idx) % k ? 0 : -1));
}
return 0;
}
} // namespace cyl
int main() { return cyl::main(); }
``` |
### Prompt
Create a solution in cpp for the following problem:
So, the New Year holidays are over. Santa Claus and his colleagues can take a rest and have guests at last. When two "New Year and Christmas Men" meet, thear assistants cut out of cardboard the letters from the guest's name and the host's name in honor of this event. Then the hung the letters above the main entrance. One night, when everyone went to bed, someone took all the letters of our characters' names. Then he may have shuffled the letters and put them in one pile in front of the door.
The next morning it was impossible to find the culprit who had made the disorder. But everybody wondered whether it is possible to restore the names of the host and his guests from the letters lying at the door? That is, we need to verify that there are no extra letters, and that nobody will need to cut more letters.
Help the "New Year and Christmas Men" and their friends to cope with this problem. You are given both inscriptions that hung over the front door the previous night, and a pile of letters that were found at the front door next morning.
Input
The input file consists of three lines: the first line contains the guest's name, the second line contains the name of the residence host and the third line contains letters in a pile that were found at the door in the morning. All lines are not empty and contain only uppercase Latin letters. The length of each line does not exceed 100.
Output
Print "YES" without the quotes, if the letters in the pile could be permuted to make the names of the "New Year and Christmas Men". Otherwise, print "NO" without the quotes.
Examples
Input
SANTACLAUS
DEDMOROZ
SANTAMOROZDEDCLAUS
Output
YES
Input
PAPAINOEL
JOULUPUKKI
JOULNAPAOILELUPUKKI
Output
NO
Input
BABBONATALE
FATHERCHRISTMAS
BABCHRISTMASBONATALLEFATHER
Output
NO
Note
In the first sample the letters written in the last line can be used to write the names and there won't be any extra letters left.
In the second sample letter "P" is missing from the pile and there's an extra letter "L".
In the third sample there's an extra letter "L".
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b, c;
cin >> a >> b >> c;
a += b;
sort(a.begin(), a.end());
sort(c.begin(), c.end());
if (a == c)
cout << "YES";
else
cout << "NO";
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
For a sequence of integers $A = \\{a_0, a_1, ..., a_{n-1}\\}$ which is sorted by ascending order, eliminate all equivalent elements.
Constraints
* $1 \leq n \leq 100,000$
* $-1000,000,000 \leq a_i \leq 1,000,000,000$
* $a_0 \leq a_1 \leq ... \leq a_{n-1}$
Input
A sequence is given in the following format.
$n$
$a_0 \; a_1 \; ,..., \; a_{n-1}$
Output
Print the sequence after eliminating equivalent elements in a line. Separate adjacency elements by a space character.
Example
Input
4
1 2 2 4
Output
1 2 4
### Response
```cpp
#include <iostream>
#include <list>
#include <algorithm>
#include <set>
using namespace std;
int main()
{
int n;
cin >> n;
set<int> A;
int a;
while (n--)
{
cin >> a;
A.insert(a);
}
//删除多余等值元素
set<int>::iterator it1 = A.begin(), it2 = ++A.begin();
// while (it2 != A.end())
// {
// if (*it1 == *it2)
// {
// A.erase(it2++);
// }
// else
// {
// it1++;
// it2++;
// }
// }
//法2：调用库函数
// A.unique();
//输出
it1 = A.begin();
cout << *it1++;
while (it1 != A.end())
{
cout << ' ' << *it1++;
}
cout << endl;
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
After you had helped Fedor to find friends in the «Call of Soldiers 3» game, he stopped studying completely. Today, the English teacher told him to prepare an essay. Fedor didn't want to prepare the essay, so he asked Alex for help. Alex came to help and wrote the essay for Fedor. But Fedor didn't like the essay at all. Now Fedor is going to change the essay using the synonym dictionary of the English language.
Fedor does not want to change the meaning of the essay. So the only change he would do: change a word from essay to one of its synonyms, basing on a replacement rule from the dictionary. Fedor may perform this operation any number of times.
As a result, Fedor wants to get an essay which contains as little letters «R» (the case doesn't matter) as possible. If there are multiple essays with minimum number of «R»s he wants to get the one with minimum length (length of essay is the sum of the lengths of all the words in it). Help Fedor get the required essay.
Please note that in this problem the case of letters doesn't matter. For example, if the synonym dictionary says that word cat can be replaced with word DOG, then it is allowed to replace the word Cat with the word doG.
Input
The first line contains a single integer m (1 ≤ m ≤ 105) — the number of words in the initial essay. The second line contains words of the essay. The words are separated by a single space. It is guaranteed that the total length of the words won't exceed 105 characters.
The next line contains a single integer n (0 ≤ n ≤ 105) — the number of pairs of words in synonym dictionary. The i-th of the next n lines contains two space-separated non-empty words xi and yi. They mean that word xi can be replaced with word yi (but not vise versa). It is guaranteed that the total length of all pairs of synonyms doesn't exceed 5·105 characters.
All the words at input can only consist of uppercase and lowercase letters of the English alphabet.
Output
Print two integers — the minimum number of letters «R» in an optimal essay and the minimum length of an optimal essay.
Examples
Input
3
AbRb r Zz
4
xR abRb
aA xr
zz Z
xr y
Output
2 6
Input
2
RuruRu fedya
1
ruruRU fedor
Output
1 10
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m, cnt = 0;
vector<string> original;
string a, b;
map<string, int> mp;
vector<int> v, gr[100005];
int len[100005], r_cnt[100005];
bool vis[100005];
bool cmp(int i, int j) {
return (r_cnt[i] < r_cnt[j] || (r_cnt[i] == r_cnt[j] && len[i] < len[j]));
}
void go(int now, int i) {
if (vis[now]) return;
vis[now] = true;
r_cnt[now] = r_cnt[i];
len[now] = len[i];
for (auto to : gr[now]) go(to, i);
}
int main() {
int i, j;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> a;
for (j = 0; j < a.size(); j++) a[j] = tolower(a[j]);
original.push_back(a);
}
cin >> m;
for (i = 1; i <= m; i++) {
int r1 = 0, len1, len2, r2 = 0;
cin >> a;
for (j = 0; j < a.size(); j++) {
a[j] = tolower(a[j]);
if (a[j] == 'r') r1++;
}
cin >> b;
for (j = 0; j < b.size(); j++) {
b[j] = tolower(b[j]);
if (b[j] == 'r') r2++;
}
if (a == b) continue;
len1 = a.size(), len2 = b.size();
int y1 = mp[a], y2 = mp[b];
if (y1 == 0) y1 = mp[a] = ++cnt;
if (y2 == 0) y2 = mp[b] = ++cnt;
r_cnt[y1] = r1;
r_cnt[y2] = r2;
len[y1] = len1;
len[y2] = len2;
gr[y2].push_back(y1);
}
for (i = 1; i <= cnt; i++) v.push_back(i);
sort(v.begin(), v.end(), cmp);
for (i = 0; i < v.size(); i++) {
if (vis[v[i]]) continue;
go(v[i], v[i]);
}
long long ansr = 0, anslen = 0;
for (i = 0; i < original.size(); i++) {
string xx = original[i];
if (mp[xx] == 0) {
for (j = 0; j < xx.size(); j++)
if (xx[j] == 'r') ansr++;
anslen += xx.size();
} else {
ansr += r_cnt[mp[xx]];
anslen += len[mp[xx]];
}
}
printf("%lld %lld\n", ansr, anslen);
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Let's define logical OR as an operation on two logical values (i. e. values that belong to the set {0, 1}) that is equal to 1 if either or both of the logical values is set to 1, otherwise it is 0. We can define logical OR of three or more logical values in the same manner:
<image> where <image> is equal to 1 if some ai = 1, otherwise it is equal to 0.
Nam has a matrix A consisting of m rows and n columns. The rows are numbered from 1 to m, columns are numbered from 1 to n. Element at row i (1 ≤ i ≤ m) and column j (1 ≤ j ≤ n) is denoted as Aij. All elements of A are either 0 or 1. From matrix A, Nam creates another matrix B of the same size using formula:
<image>.
(Bij is OR of all elements in row i and column j of matrix A)
Nam gives you matrix B and challenges you to guess matrix A. Although Nam is smart, he could probably make a mistake while calculating matrix B, since size of A can be large.
Input
The first line contains two integer m and n (1 ≤ m, n ≤ 100), number of rows and number of columns of matrices respectively.
The next m lines each contain n integers separated by spaces describing rows of matrix B (each element of B is either 0 or 1).
Output
In the first line, print "NO" if Nam has made a mistake when calculating B, otherwise print "YES". If the first line is "YES", then also print m rows consisting of n integers representing matrix A that can produce given matrix B. If there are several solutions print any one.
Examples
Input
2 2
1 0
0 0
Output
NO
Input
2 3
1 1 1
1 1 1
Output
YES
1 1 1
1 1 1
Input
2 3
0 1 0
1 1 1
Output
YES
0 0 0
0 1 0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int m, n, i, j, x = 0, y = 0, f;
long int c1 = 0, c2 = 0, o1 = 0, o2 = 0;
cin >> m >> n;
int a[m][n], b[m][n], v[m][n];
for (i = 0; i < m; i++) {
for (j = 0; j < n; j++) {
cin >> b[i][j];
a[i][j] = 0;
v[i][j] = 0;
}
}
while (x != m && y != n) {
f = 0;
for (i = 0; i < m; i++) {
if (b[i][y] == 0) {
f = 1;
break;
}
}
for (i = 0; i < n; i++) {
if (b[x][i] == 0) {
f = 1;
break;
}
}
if (f == 0) {
a[x][y] = 1;
for (i = 0; i < m; i++) {
v[i][y] = 1;
}
for (i = 0; i < n; i++) {
v[x][i] = 1;
}
}
y++;
if (y == n) {
x++;
y = 0;
}
}
for (i = 0; i < m; i++) {
for (j = 0; j < n; j++) {
if (a[i][j] == 0) c1++;
if (v[i][j] == 1) o1++;
if (b[i][j] == 0)
c2++;
else
o2++;
}
}
if ((c1 == (m * n) && c2 != (m * n)) || (o2 != o1))
cout << "NO";
else {
cout << "YES" << endl;
for (i = 0; i < m; i++) {
for (j = 0; j < n; j++) {
cout << a[i][j] << " ";
}
cout << endl;
}
}
return 0;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
A great king of a certain country suddenly decided to visit the land of a friendly country. The country is famous for trains, and the king visits various stations.
There are 52 train stations, each with a single uppercase or lowercase alphabetic name (no overlapping names). The line of this train is circular, with station a next to station b, station b next to station c, then station z next to station A, then station B, and so on. Proceed in order, and after Z station, it becomes a station and returns to the original. It is a single track, and there are no trains running in the opposite direction.
One day, a newspaper reporter got a list of the stations the King would visit.
"DcdkIlkP ..."
It is said that they will visit d station first, then c station, then d station, and so on. With this, when I thought that I could follow up on the king of a great country, I discovered something unexpected. The list was encrypted for counter-terrorism! A fellow reporter reportedly obtained the key to break the code. The reporter immediately gave him the key and started to modify the list. The key consists of a sequence of numbers.
"3 1 4 5 3"
This number means that the first station you visit is the one three stations before the one on the list. The station you visit second is the station in front of the second station on the list, which indicates how many stations you actually visit are in front of the stations on the list. The reporter started to fix it, but when I asked my friends what to do because the number of keys was smaller than the number of stations to visit, if you use the last key, use the first key again. It seems to be good. And the reporter was finally able to revise the list.
"AbZfFijL ..."
With this, there would be nothing scary anymore, and as soon as I thought so, an unexpected situation was discovered. The Great King stayed for days, and there was a list and keys for each date. The reporter was instructed by his boss to decrypt the entire list, but the amount was not enough for him alone. Your job is to help him and create a program that will automatically decrypt this list.
Input
The input consists of multiple datasets. The format of each data set is as follows.
n
k1 k2 ... kn
s
n is an integer representing the number of keys and can be assumed to be between 1 and 100. The following line contains a list of keys. ki indicates the i-th key. It can be assumed that it is 1 or more and 52 or less. s is a character string consisting of uppercase and lowercase letters, and indicates a list of stations to visit. It may be assumed that it is 1 or more and 100 or less. n = 0 indicates the end of input. This is not included in the dataset.
Output
Print the decrypted list for each dataset on one line each.
Sample Input
2
1 2
bdd
3
3 2 1
DDDA
Five
3 1 4 5 3
dcdkIlkP
0
Output for Sample Input
abc
ABCx
abZfFijL
Example
Input
2
1 2
bdd
3
3 2 1
DDDA
5
3 1 4 5 3
dcdkIlkP
0
Output
abc
ABCx
abZfFijL
### Response
```cpp
#include<iostream>
using namespace std;
char ch[52];
int n,t[105];
string s;
int main(){
ch[0]='a';ch[26]='A';
for(int i=1;i<26;i++){
ch[i]=ch[i-1]+1;
ch[i+26]=ch[i+25]+1;
}
while(1){
cin>>n;
if(n==0)break;
for(int i=0;i<n;i++)cin>>t[i],t[i]%=52;
cin>>s;
for(int i=0;i<(int)s.size();i++){
int j=i%n;
int a=('a'<=s[i]?s[i]-'a':s[i]-'A'+26);
a=(a+52-t[j])%52;
cout<<ch[a];
}
cout<<endl;
}
return 0;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
Beroffice text editor has a wide range of features that help working with text. One of the features is an automatic search for typos and suggestions of how to fix them.
Beroffice works only with small English letters (i.e. with 26 letters from a to z). Beroffice thinks that a word is typed with a typo if there are three or more consonants in a row in the word. The only exception is that if the block of consonants has all letters the same, then this block (even if its length is greater than three) is not considered a typo. Formally, a word is typed with a typo if there is a block of not less that three consonants in a row, and there are at least two different letters in this block.
For example:
* the following words have typos: "hellno", "hackcerrs" and "backtothefutttture";
* the following words don't have typos: "helllllooooo", "tobeornottobe" and "oooooo".
When Beroffice editor finds a word with a typo, it inserts as little as possible number of spaces in this word (dividing it into several words) in such a way that each of the resulting words is typed without any typos.
Implement this feature of Beroffice editor. Consider the following letters as the only vowels: 'a', 'e', 'i', 'o' and 'u'. All the other letters are consonants in this problem.
Input
The only line contains a non-empty word consisting of small English letters. The length of the word is between 1 and 3000 letters.
Output
Print the given word without any changes if there are no typos.
If there is at least one typo in the word, insert the minimum number of spaces into the word so that each of the resulting words doesn't have any typos. If there are multiple solutions, print any of them.
Examples
Input
hellno
Output
hell no
Input
abacaba
Output
abacaba
Input
asdfasdf
Output
asd fasd f
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
string s;
bool is_sogl(char h) {
if (h == 'a' || h == 'e' || h == 'i' || h == 'o' || h == 'u') return false;
return true;
}
int main() {
cin >> s;
int now = 0;
for (int i = 0; i < s.size(); i++) {
if (is_sogl(s[i])) {
cout << s[i];
i++;
int how = 1;
while (i < s.size() && s[i] == s[i - 1]) {
cout << s[i];
i++;
how++;
}
now++;
if (i != s.size() && is_sogl(s[i])) {
if (how > 1) {
cout << ' ';
now = 0;
} else if (now > 1) {
cout << ' ';
now = 0;
} else if (i + 1 != s.size() && s[i] == s[i + 1]) {
cout << s[i++] << ' ';
now = 0;
}
}
i--;
} else {
cout << s[i];
now = 0;
}
}
return 0;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
Nothing has changed since the last round. Dima and Inna still love each other and want to be together. They've made a deal with Seryozha and now they need to make a deal with the dorm guards...
There are four guardposts in Dima's dorm. Each post contains two guards (in Russia they are usually elderly women). You can bribe a guard by a chocolate bar or a box of juice. For each guard you know the minimum price of the chocolate bar she can accept as a gift and the minimum price of the box of juice she can accept as a gift. If a chocolate bar for some guard costs less than the minimum chocolate bar price for this guard is, or if a box of juice for some guard costs less than the minimum box of juice price for this guard is, then the guard doesn't accept such a gift.
In order to pass through a guardpost, one needs to bribe both guards.
The shop has an unlimited amount of juice and chocolate of any price starting with 1. Dima wants to choose some guardpost, buy one gift for each guard from the guardpost and spend exactly n rubles on it.
Help him choose a post through which he can safely sneak Inna or otherwise say that this is impossible. Mind you, Inna would be very sorry to hear that!
Input
The first line of the input contains integer n (1 ≤ n ≤ 105) — the money Dima wants to spend. Then follow four lines describing the guardposts. Each line contains four integers a, b, c, d (1 ≤ a, b, c, d ≤ 105) — the minimum price of the chocolate and the minimum price of the juice for the first guard and the minimum price of the chocolate and the minimum price of the juice for the second guard, correspondingly.
Output
In a single line of the output print three space-separated integers: the number of the guardpost, the cost of the first present and the cost of the second present. If there is no guardpost Dima can sneak Inna through at such conditions, print -1 in a single line.
The guardposts are numbered from 1 to 4 according to the order given in the input.
If there are multiple solutions, you can print any of them.
Examples
Input
10
5 6 5 6
6 6 7 7
5 8 6 6
9 9 9 9
Output
1 5 5
Input
10
6 6 6 6
7 7 7 7
4 4 4 4
8 8 8 8
Output
3 4 6
Input
5
3 3 3 3
3 3 3 3
3 3 3 3
3 3 3 3
Output
-1
Note
Explanation of the first example.
The only way to spend 10 rubles to buy the gifts that won't be less than the minimum prices is to buy two 5 ruble chocolates to both guards from the first guardpost.
Explanation of the second example.
Dima needs 12 rubles for the first guardpost, 14 for the second one, 16 for the fourth one. So the only guardpost we can sneak through is the third one. So, Dima can buy 4 ruble chocolate for the first guard and 6 ruble juice of the second guard.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[4][4];
int s = 1;
int ts;
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) cin >> a[i][j];
if (s)
if (min(a[i][0], a[i][1]) + min(a[i][2], a[i][3]) <= n) {
s = 0;
ts = i;
}
}
if (s) {
cout << -1;
return 0;
}
cout << ts + 1 << ' ' << min(a[ts][0], a[ts][1]) << ' '
<< n - min(a[ts][0], a[ts][1]);
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
In a small but very proud high school it was decided to win ACM ICPC. This goal requires to compose as many teams of three as possible, but since there were only 6 students who wished to participate, the decision was to build exactly two teams.
After practice competition, participant number i got a score of ai. Team score is defined as sum of scores of its participants. High school management is interested if it's possible to build two teams with equal scores. Your task is to answer that question.
Input
The single line contains six integers a1, ..., a6 (0 ≤ ai ≤ 1000) — scores of the participants
Output
Print "YES" (quotes for clarity), if it is possible to build teams with equal score, and "NO" otherwise.
You can print each character either upper- or lowercase ("YeS" and "yes" are valid when the answer is "YES").
Examples
Input
1 3 2 1 2 1
Output
YES
Input
1 1 1 1 1 99
Output
NO
Note
In the first sample, first team can be composed of 1st, 2nd and 6th participant, second — of 3rd, 4th and 5th: team scores are 1 + 3 + 1 = 2 + 1 + 2 = 5.
In the second sample, score of participant number 6 is too high: his team score will be definitely greater.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int a[7], cnt;
int main() {
for (int i = 1; i <= 6; i++) cin >> a[i], cnt += a[i];
for (int i = 1; i <= 6; i++)
for (int j = i + 1; j <= 6; j++)
for (int k = j + 1; k <= 6; k++)
if ((a[i] + a[j] + a[k]) * 2 == cnt) {
cout << "YES";
return 0;
}
cout << "NO";
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
We'll call a sequence of integers a good k-d sequence if we can add to it at most k numbers in such a way that after the sorting the sequence will be an arithmetic progression with difference d.
You got hold of some sequence a, consisting of n integers. Your task is to find its longest contiguous subsegment, such that it is a good k-d sequence.
Input
The first line contains three space-separated integers n, k, d (1 ≤ n ≤ 2·105; 0 ≤ k ≤ 2·105; 0 ≤ d ≤ 109). The second line contains n space-separated integers: a1, a2, ..., an ( - 109 ≤ ai ≤ 109) — the actual sequence.
Output
Print two space-separated integers l, r (1 ≤ l ≤ r ≤ n) show that sequence al, al + 1, ..., ar is the longest subsegment that is a good k-d sequence.
If there are multiple optimal answers, print the one with the minimum value of l.
Examples
Input
6 1 2
4 3 2 8 6 2
Output
3 5
Note
In the first test sample the answer is the subsegment consisting of numbers 2, 8, 6 — after adding number 4 and sorting it becomes sequence 2, 4, 6, 8 — the arithmetic progression with difference 2.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int sum = 0;
char c = getchar();
bool f = 0;
while (c < '0' || c > '9') {
if (c == '-') f = 1;
c = getchar();
}
while (c >= '0' && c <= '9') {
sum = sum * 10 + c - '0';
c = getchar();
}
if (f) return -sum;
return sum;
}
const int N = 200005;
const int orz = 2000000;
const int otz = 1000000005;
int n, K, d, a[N], b[N], c[N];
namespace Seg {
int lazy[N * 4], t[N * 4], v, rch;
inline void push(int p) {
if (!lazy[p]) return;
int x = lazy[p], l = p << 1, r = (l | 1);
t[l] += x;
t[r] += x;
lazy[l] += x;
lazy[r] += x;
lazy[p] = 0;
}
inline void ch(int p, int l, int r, int L, int R) {
if (l == L && r == R) {
lazy[p] += v;
t[p] += v;
return;
}
int mid = (l + r) >> 1;
push(p);
if (R <= mid)
ch(p << 1, l, mid, L, R);
else if (L > mid)
ch(p << 1 | 1, mid + 1, r, L, R);
else
ch(p << 1, l, mid, L, mid), ch(p << 1 | 1, mid + 1, r, mid + 1, R);
t[p] = min(t[p << 1], t[p << 1 | 1]);
}
inline void ask(int p, int l, int r) {
if (l == r) {
rch = l;
return;
}
int mid = (l + r) >> 1;
push(p);
if (t[p << 1] < K)
ask(p << 1, l, mid);
else
ask(p << 1 | 1, mid + 1, r);
}
} // namespace Seg
using namespace Seg;
int s1[N], s2[N], t1, t2;
int g[N], H[N], m;
int main() {
int i, r, x, st = 1, ed = 1, ans = 1, ino = 0;
n = read();
K = read();
d = read();
for (i = 1; i <= n; i++) a[i] = read() + otz;
if (!d) {
for (i = 1; i <= n; i = r) {
r = i;
while (r <= n && a[r] == a[i]) r++;
if (r - i > ans) ans = r - i, st = i, ed = r - 1;
}
printf("%d %d", st, ed);
return 0;
}
for (i = 1; i <= n; i++) g[i] = a[i];
sort(g + 1, g + n + 1);
m = unique(g + 1, g + n + 1) - g - 1;
for (i = 1; i <= n; i++) b[i] = a[i] % d, c[i] = a[i] / d;
a[0] = a[1];
b[0] = b[1];
v = orz;
ch(1, 1, n, 1, n);
for (i = 1; i <= n; i++) {
if (b[i] != b[i - 1]) v = orz, ch(1, 1, n, ino + 1, i - 1), ino = i - 1;
x = lower_bound(g + 1, g + m + 1, a[i]) - g;
if (H[x] > ino) v = orz, ch(1, 1, n, ino + 1, H[x]), ino = H[x];
while (t1 && a[i] > a[s1[t1]])
v = c[i] - c[s1[t1]], ch(1, 1, n, s1[t1 - 1] + 1, s1[t1]), t1--;
while (t2 && a[i] < a[s2[t2]])
v = c[s2[t2]] - c[i], ch(1, 1, n, s2[t2 - 1] + 1, s2[t2]), t2--;
H[x] = i;
s1[++t1] = i;
s2[++t2] = i;
v = -1;
ch(1, 1, n, 1, i);
v = -orz;
ch(1, 1, n, i, i);
ask(1, 1, n);
if (i - rch + 1 > ans) ans = i - rch + 1, st = rch, ed = i;
}
printf("%d %d", st, ed);
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
You are given an array a consisting of n positive integers. You pick two integer numbers l and r from 1 to n, inclusive (numbers are picked randomly, equiprobably and independently). If l > r, then you swap values of l and r. You have to calculate the expected value of the number of unique elements in segment of the array from index l to index r, inclusive (1-indexed).
Input
The first line contains one integer number n (1 ≤ n ≤ 106). The second line contains n integer numbers a1, a2, ... an (1 ≤ ai ≤ 106) — elements of the array.
Output
Print one number — the expected number of unique elements in chosen segment.
Your answer will be considered correct if its absolute or relative error doesn't exceed 10 - 4 — formally, the answer is correct if <image>, where x is jury's answer, and y is your answer.
Examples
Input
2
1 2
Output
1.500000
Input
2
2 2
Output
1.000000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
map<int, int> lastPos;
int n;
int main(void) {
std::ios_base::sync_with_stdio(false);
cin >> n;
long long sum = 0;
long long prefixSum = 0;
for (int i = 1; i <= n; i++) {
int num;
cin >> num;
prefixSum += (i - lastPos[num]);
sum += prefixSum;
lastPos[num] = i;
}
sum -= n;
sum *= 2;
sum += n;
printf("%.9f\n", double(sum) / n / n);
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
Ksusha the Squirrel is standing at the beginning of a straight road, divided into n sectors. The sectors are numbered 1 to n, from left to right. Initially, Ksusha stands in sector 1.
Ksusha wants to walk to the end of the road, that is, get to sector n. Unfortunately, there are some rocks on the road. We know that Ksusha hates rocks, so she doesn't want to stand in sectors that have rocks.
Ksusha the squirrel keeps fit. She can jump from sector i to any of the sectors i + 1, i + 2, ..., i + k.
Help Ksusha! Given the road description, say if she can reach the end of the road (note, she cannot stand on a rock)?
Input
The first line contains two integers n and k (2 ≤ n ≤ 3·105, 1 ≤ k ≤ 3·105). The next line contains n characters — the description of the road: the i-th character equals ".", if the i-th sector contains no rocks. Otherwise, it equals "#".
It is guaranteed that the first and the last characters equal ".".
Output
Print "YES" (without the quotes) if Ksusha can reach the end of the road, otherwise print "NO" (without the quotes).
Examples
Input
2 1
..
Output
YES
Input
5 2
.#.#.
Output
YES
Input
7 3
.#.###.
Output
NO
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base ::sync_with_stdio(false), cin.tie(NULL), cout.tie(0);
int a, b, mx = 0, ct = 0;
cin >> a >> b;
string s;
cin >> s;
for (long long int i = 0; i < s.size(); i++) {
if (s[i] == '#')
ct++;
else {
mx = max(mx, ct);
ct = 0;
}
}
cout << ((mx >= b) ? "NO" : "YES");
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
After your debut mobile game "Nim" blew up, you decided to make a sequel called "Nim 2". This game will expand on the trusted Nim game formula, adding the much awaited second heap!
In the game, there are two heaps, each containing a non-negative number of stones. Two players make moves in turn. On their turn, a player can take any positive number of stones from either one of the heaps. A player who is unable to move loses the game.
To make the game easier to playtest, you've introduced developer shortcuts. There are n shortcut positions (x_1, y_1), …, (x_n, y_n). These change the game as follows: suppose that before a player's turn the first and second heap contain x and y stones respectively. If the pair (x, y) is equal to one of the pairs (x_i, y_i), then the player about to move loses instantly, otherwise they are able to make moves as normal. Note that in the above explanation the two heaps and all pairs are ordered, that is, x must refer to the size of the first heap, and y must refer to the size of the second heap.
The game release was followed by too much celebration, and next thing you know is developer shortcuts made their way to the next official update of the game! Players now complain that the AI opponent has become unbeatable at certain stages of the game. You now have to write a program to figure out which of the given initial positions can be won by the starting player, assuming both players act optimally.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 10^5) — the number of shortcut positions, and the number of initial positions that need to be evaluated.
The following n lines describe shortcut positions. The i-th of these lines contains two integers x_i, y_i (0 ≤ x_i, y_i ≤ 10^9). It is guaranteed that all shortcut positions are distinct.
The following m lines describe initial positions. The i-th of these lines contains two integers a_i, b_i (0 ≤ a_i, b_i ≤ 10^9) — the number of stones in the first and second heap respectively. It is guaranteed that all initial positions are distinct. However, initial positions are not necessarily distinct from shortcut positions.
Output
For each initial position, on a separate line print "WIN" if the starting player is able to win from this position, and "LOSE" otherwise.
Example
Input
3 5
3 0
0 1
2 2
0 0
1 1
2 2
3 3
5 4
Output
LOSE
WIN
LOSE
WIN
LOSE
### Response
```cpp
#define DEBUG 0
#include <bits/stdc++.h>
using namespace std;
#if DEBUG
// basic debugging macros
int __i__,__j__;
#define printLine(l) for(__i__=0;__i__<l;__i__++){cout<<"-";}cout<<endl
#define printLine2(l,c) for(__i__=0;__i__<l;__i__++){cout<<c;}cout<<endl
#define printVar(n) cout<<#n<<": "<<n<<endl
#define printArr(a,l) cout<<#a<<": ";for(__i__=0;__i__<l;__i__++){cout<<a[__i__]<<" ";}cout<<endl
#define print2dArr(a,r,c) cout<<#a<<":\n";for(__i__=0;__i__<r;__i__++){for(__j__=0;__j__<c;__j__++){cout<<a[__i__][__j__]<<" ";}cout<<endl;}
#define print2dArr2(a,r,c,l) cout<<#a<<":\n";for(__i__=0;__i__<r;__i__++){for(__j__=0;__j__<c;__j__++){cout<<setw(l)<<setfill(' ')<<a[__i__][__j__]<<" ";}cout<<endl;}
// advanced debugging class
// debug 1,2,'A',"test";
class _Debug {
public:
template<typename T>
_Debug& operator,(T val) {
cout << val << endl;
return *this;
}
};
#define debug _Debug(),
#else
#define printLine(l)
#define printLine2(l,c)
#define printVar(n)
#define printArr(a,l)
#define print2dArr(a,r,c)
#define print2dArr2(a,r,c,l)
#define debug
#endif
// define
#define MAX_VAL 999999999
#define MAX_VAL_2 999999999999999999LL
#define EPS 1e-6
#define mp make_pair
#define pb push_back
// typedef
typedef unsigned int UI;
typedef long long int LLI;
typedef unsigned long long int ULLI;
typedef unsigned short int US;
typedef pair<int,int> pii;
typedef pair<LLI,LLI> plli;
typedef vector<int> vi;
typedef vector<LLI> vlli;
typedef vector<pii> vpii;
typedef vector<plli> vplli;
// ---------- END OF TEMPLATE ----------
struct point { int x,y,t; };
bool comp(point a,point b) {
if (a.x == b.x) {
if (a.y == b.y) return a.t < b.t;
else return a.y < b.y;
}
else return a.x < b.x;
}
vector<point> vv;
vi xx;
int ans[100000];
set<pii> win;
int main() {
int i;
int n,m,x,y;
scanf("%d %d",&n,&m);
for (i = 0; i < n; i++) scanf("%d %d",&x,&y),vv.pb((point){x,y,-1}),xx.pb(x);
vv.pb((point){0,0,-1}),xx.pb(0);
for (i = 0; i < m; i++) scanf("%d %d",&x,&y),vv.pb((point){x,y,i}),xx.pb(x);
sort(vv.begin(),vv.end(),comp);
sort(xx.begin(),xx.end());
xx.resize(unique(xx.begin(),xx.end())-xx.begin());
int j = 0,k,c = -1;
win.insert(mp(0,1.1e9));
for (i = 0; i < xx.size(); i++) {
int d = xx[i]-c-1;
while (d > 0) {
pii p = *win.begin();
win.erase(win.begin());
if (d < p.second-p.first+1) {
p.first += d,d = 0;
win.insert(p);
}
else d -= p.second-p.first+1;
}
vi lose;
vpii qq;
while ((j < vv.size()) && (vv[j].x == xx[i])) {
if (vv[j].t == -1) lose.pb(vv[j].y);
else qq.pb(mp(vv[j].y,vv[j].t));
j++;
}
if (lose.empty() || (lose[0] > win.begin()->first)) lose.insert(lose.begin(),win.begin()->first);
for (k = 0; k < qq.size(); k++) {
if (binary_search(lose.begin(),lose.end(),qq[k].first)) ans[qq[k].second] = 0;
else ans[qq[k].second] = 1;
}
for (k = 0; k < lose.size(); k++) {
auto it = win.upper_bound(mp(lose[k],2e9));
if (it != win.begin()) {
it--;
if ((it->first <= lose[k]) && (lose[k] <= it->second)) {
if (it->first <= lose[k]-1) win.insert(mp(it->first,lose[k]-1));
if (lose[k]+1 <= it->second) win.insert(mp(lose[k]+1,it->second));
win.erase(it);
}
}
}
c = xx[i];
}
for (i = 0; i < m; i++) printf(ans[i] ? "WIN\n":"LOSE\n");
return 0;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
Kyoya Ootori wants to take the train to get to school. There are n train stations and m one-way train lines going between various stations. Kyoya is currently at train station 1, and the school is at station n. To take a train, he must pay for a ticket, and the train also takes a certain amount of time. However, the trains are not perfect and take random amounts of time to arrive at their destination. If Kyoya arrives at school strictly after t time units, he will have to pay a fine of x.
Each train line is described by a ticket price, and a probability distribution on the time the train takes. More formally, train line i has ticket cost ci, and a probability distribution pi, k which denotes the probability that this train will take k time units for all 1 ≤ k ≤ t. Amounts of time that each of the trains used by Kyouya takes are mutually independent random values (moreover, if Kyoya travels along the same train more than once, it is possible for the train to take different amounts of time and those amounts are also independent one from another).
Kyoya wants to get to school by spending the least amount of money in expectation (for the ticket price plus possible fine for being late). Of course, Kyoya has an optimal plan for how to get to school, and every time he arrives at a train station, he may recalculate his plan based on how much time he has remaining. What is the expected cost that Kyoya will pay to get to school if he moves optimally?
Input
The first line of input contains four integers n, m, t, x (2 ≤ n ≤ 50, 1 ≤ m ≤ 100, 1 ≤ t ≤ 20 000, 0 ≤ x ≤ 106).
The next 2m lines contain the description of the trains.
The 2i-th line will have 3 integers ai, bi, ci, representing a one way train from station ai to bi with ticket cost ci (1 ≤ ai, bi ≤ n, ai ≠ bi, 0 ≤ ci ≤ 106). There will always be at least one path from any station to the school.
The (2i + 1)-th line will contain t integers, pi, 1, pi, 2, ..., pi, t where pi, k / 100000 is the probability that this train will take k units of time to traverse (0 ≤ pi, k ≤ 100 000 for 1 ≤ k ≤ t, <image>).
It is guaranteed that there is no more than one train between each pair of platforms in each of the directions.
Output
Print a single real number that is equal to an optimal expected cost of getting to school. The answer will be considered correct if its relative or absolute error doesn't exceed 10 - 6.
Examples
Input
4 4 5 1
1 2 0
50000 0 50000 0 0
2 3 0
10000 0 0 0 90000
3 4 0
100000 0 0 0 0
2 4 0
0 0 0 50000 50000
Output
0.7000000000
Input
4 4 5 1
1 2 100
50000 0 50000 0 0
2 3 100
10000 0 0 0 90000
3 4 100
100000 0 0 0 0
2 4 100
0 0 0 50000 50000
Output
200.7500000000
Note
The optimal strategy in the first case is as follows:
First, travel along first train line. With probability 1 / 2 Kyoya will take 1 time unit. Otherwise, Kyoya will take 3 time units.
If the train takes 1 time unit, travel along the 4th train line. Kyoya will make it to school in time with probability 1 / 2. Otherwise, if the train takes 3 time units, travel along the 2nd train line. Kyoya will make it to school in time with probability 1 / 10.
Since the cost of all train lines are zero, we can just look at the probability that Kyoya will incur the penalty. The probability that Kyoya will have to pay the penalty is 1 / 2 × 1 / 2 + 1 / 2 × 9 / 10 = 7 / 10. We can show that no other strategy is strictly better.
The optimal strategy in the second case is to travel along 1 → 2 → 4 no matter what. Kyoya will incur the penalty with probability 3 / 4, and the cost of the trains is 200, thus the expected cost is 200.75.
### Response
```cpp
#include <bits/stdc++.h>
inline int in() {
int k = 0;
char ch = getchar();
while (ch < '-') ch = getchar();
while (ch > '-') k = k * 10 + ch - '0', ch = getchar();
return k;
}
const int N = 3e5 + 5;
const long double PI = acos(-1);
int rev[N];
inline void get_rev(int len) {
for (int i = 0; i < len; ++i)
rev[i] = (rev[i >> 1] >> 1) | ((i & 1) ? len >> 1 : 0);
}
struct E {
double x, y;
E() {}
E(double a, double b) : x(a), y(b) {}
E operator=(const int &a) {
x = a, y = 0;
return *this;
}
E conj() { return E(x, -y); }
} omg[N], a[N], b[N];
E operator+(const E &a, const E &b) { return E(a.x + b.x, a.y + b.y); }
E operator-(const E &a, const E &b) { return E(a.x - b.x, a.y - b.y); }
E operator*(const E &a, const E &b) {
return E(a.x * b.x - a.y * b.y, a.x * b.y + a.y * b.x);
}
struct node {
int u, d;
node(int u = 0, int d = 0) : u(u), d(d) {}
};
inline bool operator<(const node &a, const node &b) { return a.d > b.d; }
std::priority_queue<node> Q;
inline void get_omg(int len) {
for (int i = 0; i < len; ++i)
omg[i] = E(cos(PI * i / len), sin(PI * i / len));
}
inline void fft(E *a, int len) {
for (int i = 0; i < len; ++i)
if (i < rev[i]) std::swap(a[i], a[rev[i]]);
for (int st = 2, m = 1; st <= len; st <<= 1, m <<= 1)
for (E *p = a, x, y; p != a + len; p += st)
for (int k = 0; k < m; ++k)
x = p[k], y = omg[len / m * k] * p[k + m], p[k] = x + y,
p[k + m] = x - y;
}
const int T = 5e4 + 5, M = 205;
double f[M][T], g[M][T], p[M][T], res[N];
int n, m, t, x, w[M], head[N], to[M], nxt[M], cnt, dis[N];
template <typename T>
inline void cmin(T &x, T y) {
if (x > y) x = y;
}
void solve(int l, int r) {
if (l > t) return;
if (l == r) {
for (int i = 1; i <= m; ++i) cmin(f[to[i]][l], g[i][l] + w[i]);
return;
}
int mid = l + r >> 1, L = r - l, len = 1;
solve(mid + 1, r);
while (len <= L << 1) len <<= 1;
get_omg(len), get_rev(len);
for (int u = 1; u <= n; ++u)
for (int e = head[u]; e; e = nxt[e]) {
for (int i = 0; i < len; ++i) a[i] = b[i] = E(0, 0);
for (int i = mid + 1; i <= r; ++i) a[i - mid - 1] = E(f[u][i], 0);
for (int i = 0; i <= L; ++i) b[i] = E(p[e][L - i], 0);
fft(a, len), fft(b, len);
for (int i = 0; i < len; ++i) a[i] = a[i] * b[i];
std::reverse(a + 1, a + len);
fft(a, len);
for (int i = 0; i < len; ++i) a[i].x /= len;
for (int i = l; i <= mid; ++i)
g[e][i] += (i - mid - 1 + L >= 0 ? a[i - mid - 1 + L].x : 0);
}
solve(l, mid);
}
int main() {
n = in(), m = in(), t = in(), x = in();
for (int i = 1; i <= m; ++i) {
int u = in(), v = in();
w[i] = in();
to[i] = u, nxt[i] = head[v], head[v] = i;
for (int j = 1; j <= t; ++j) p[i][j] = ((double)in()) / 100000;
}
Q.push(node(n, 0));
memset(dis, 0x3f, sizeof dis);
dis[n] = 0;
while (!Q.empty()) {
node now = Q.top();
Q.pop();
int u = now.u, d = now.d;
if (d != dis[u]) continue;
for (int i = head[u]; i; i = nxt[i])
if (dis[to[i]] > dis[u] + w[i])
dis[to[i]] = dis[u] + w[i], Q.push(node(to[i], dis[to[i]]));
}
for (int i = 1; i <= n; ++i)
for (int j = 0; j <= t * 2; ++j) f[i][j] = 1e18;
for (int i = 1; i <= n; ++i)
for (int j = t + 1; j <= t * 2; ++j) f[i][j] = dis[i] + x;
for (int i = 0; i <= t; ++i) f[n][i] = 0;
solve(0, t << 1);
printf("%.10lf\n", f[1][0]);
return 0;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
Gerald found a table consisting of n rows and m columns. As a prominent expert on rectangular tables, he immediately counted the table's properties, that is, the minimum of the numbers in the corners of the table (minimum of four numbers). However, he did not like the final value — it seemed to be too small. And to make this value larger, he decided to crop the table a little: delete some columns on the left and some on the right, as well as some rows from the top and some from the bottom. Find what the maximum property of the table can be after such cropping. Note that the table should have at least two rows and at least two columns left in the end. The number of cropped rows or columns from each of the four sides can be zero.
Input
The first line contains two space-separated integers n and m (2 ≤ n, m ≤ 1000). The following n lines describe the table. The i-th of these lines lists the space-separated integers ai, 1, ai, 2, ..., ai, m (0 ≤ ai, j ≤ 109) — the m numbers standing in the i-th row of the table.
Output
Print the answer to the problem.
Examples
Input
2 2
1 2
3 4
Output
1
Input
3 3
1 0 0
0 1 1
1 0 0
Output
0
Note
In the first test case Gerald cannot crop the table — table contains only two rows and only two columns.
In the second test case if we'll crop the table, the table will contain zero in some corner cell. Also initially it contains two zeros in the corner cells, so the answer is 0.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int a[1005][1005];
int v[1005];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) scanf("%d", &a[i][j]);
int ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
int m1 = 0, m2 = 0;
for (int k = 1; k <= m; k++) {
int l = min(a[i][k], a[j][k]);
if (l > m1) {
m2 = m1;
m1 = l;
} else if (l > m2) {
m2 = l;
}
}
ans = max(ans, m2);
}
}
printf("%d\n", ans);
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
Alice and Bob are playing a game with a string of characters, with Alice going first. The string consists n characters, each of which is one of the first k letters of the alphabet. On a player’s turn, they can either arbitrarily permute the characters in the words, or delete exactly one character in the word (if there is at least one character). In addition, their resulting word cannot have appeared before throughout the entire game. The player unable to make a valid move loses the game.
Given n, k, p, find the number of words with exactly n characters consisting of the first k letters of the alphabet such that Alice will win if both Alice and Bob play optimally. Return this number modulo the prime number p.
Input
The first line of input will contain three integers n, k, p (1 ≤ n ≤ 250 000, 1 ≤ k ≤ 26, 108 ≤ p ≤ 109 + 100, p will be prime).
Output
Print a single integer, the number of winning words for Alice, modulo p.
Example
Input
4 2 100000007
Output
14
Note
There are 14 strings that that Alice can win with. For example, some strings are "bbaa" and "baaa". Alice will lose on strings like "aaaa" or "bbbb".
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 250010;
unsigned long long P, fa[N], inv[N], k, ans, ans1, f[18][N];
unsigned long long sqr(unsigned long long x) { return x * x % P; }
int n;
unsigned long long poww(unsigned long long a, unsigned long long n) {
if (n == 0) return 1;
if (n % 2 == 0) return sqr(poww(a, n / 2));
return sqr(poww(a, n / 2)) * a % P;
}
unsigned long long C(int a, int b) {
if (b > a) return 0;
return fa[a] * inv[b] % P * inv[a - b] % P;
}
int min(int a, int b) { return a < b ? a : b; }
inline void calc() {
int l, i, j;
for (l = 2; l <= min(17, k); l++) {
for (i = n; i >= (1 << l) - 1; i = (i - 1) & n) {
for (j = i; j >= (1 << (l - 1)) - 1; j = (j - 1) & i) {
if (i == j) continue;
f[l][i] += f[l - 1][j] * inv[i ^ j];
if (f[l][i] > 17446744073709551616ull) {
f[l][i] %= P;
}
}
f[l][i] %= P;
}
ans1 = (ans1 + f[l][n] * C(k, l)) % P;
}
}
int main() {
int i, j, l;
scanf("%d%lld%lld", &n, &k, &P);
ans = 1;
for (i = 1; i <= n; i++) ans = ans * k % P;
if (n % 2 == 1) {
printf("%llu\n", ans);
return 0;
}
fa[0] = 1;
for (i = 1; i <= n; i++) fa[i] = fa[i - 1] * i % P;
inv[0] = 1;
for (i = 1; i <= n; i++) inv[i] = poww(fa[i], P - 2);
memset(f, 0, sizeof(f));
for (i = 1; i <= n; i++) f[1][i] = inv[i];
ans1 = f[1][n] * k % P;
calc();
ans1 = ans1 * fa[n] % P;
printf("%llu\n", (ans - ans1 + P) % P);
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
Paul is at the orchestra. The string section is arranged in an r × c rectangular grid and is filled with violinists with the exception of n violists. Paul really likes violas, so he would like to take a picture including at least k of them. Paul can take a picture of any axis-parallel rectangle in the orchestra. Count the number of possible pictures that Paul can take.
Two pictures are considered to be different if the coordinates of corresponding rectangles are different.
Input
The first line of input contains four space-separated integers r, c, n, k (1 ≤ r, c, n ≤ 3000, 1 ≤ k ≤ min(n, 10)) — the number of rows and columns of the string section, the total number of violas, and the minimum number of violas Paul would like in his photograph, respectively.
The next n lines each contain two integers xi and yi (1 ≤ xi ≤ r, 1 ≤ yi ≤ c): the position of the i-th viola. It is guaranteed that no location appears more than once in the input.
Output
Print a single integer — the number of photographs Paul can take which include at least k violas.
Examples
Input
2 2 1 1
1 2
Output
4
Input
3 2 3 3
1 1
3 1
2 2
Output
1
Input
3 2 3 2
1 1
3 1
2 2
Output
4
Note
We will use '*' to denote violinists and '#' to denote violists.
In the first sample, the orchestra looks as follows:
*#
**
Paul can take a photograph of just the viola, the 1 × 2 column containing the viola, the 2 × 1 row containing the viola, or the entire string section, for 4 pictures total.
In the second sample, the orchestra looks as follows:
#*
*#
#*
Paul must take a photograph of the entire section.
In the third sample, the orchestra looks the same as in the second sample.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <class C>
constexpr int sz(const C &c) {
return int(c.size());
}
using ll = long long;
constexpr const char nl = '\n', sp = ' ';
template <class C>
void partial_sum_2d(const C &A, int N, int M, C &pre) {
for (int i = 0; i < N; i++)
for (int j = 0; j < M; j++) {
pre[i][j] = A[i][j];
if (i > 0) pre[i][j] += pre[i - 1][j];
if (j > 0) pre[i][j] += pre[i][j - 1];
if (i > 0 && j > 0) pre[i][j] -= pre[i - 1][j - 1];
}
}
template <class C>
auto rsq(const C &pre, int u, int d, int l, int r) ->
typename decay<decltype(pre[d][r])>::type {
typename decay<decltype(pre[d][r])>::type v = pre[d][r];
if (u > 0) v -= pre[u - 1][r];
if (l > 0) v -= pre[d][l - 1];
if (u > 0 && l > 0) v += pre[u - 1][l - 1];
return v;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int R, C, N, K;
cin >> R >> C >> N >> K;
vector<vector<int>> A(R, vector<int>(C, 0));
for (int i = 0; i < N; i++) {
int x, y;
cin >> x >> y;
A[--x][--y]++;
}
partial_sum_2d(A, R, C, A);
int ans = 0;
for (int u = 0; u < R; u++)
for (int d = u; d < R; d++)
for (int l = 0; l < C; l++)
for (int r = l; r < C; r++) ans += rsq(A, u, d, l, r) >= K;
cout << ans << nl;
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Arkady and his friends love playing checkers on an n × n field. The rows and the columns of the field are enumerated from 1 to n.
The friends have recently won a championship, so Arkady wants to please them with some candies. Remembering an old parable (but not its moral), Arkady wants to give to his friends one set of candies per each cell of the field: the set of candies for cell (i, j) will have exactly (i^2 + j^2) candies of unique type.
There are m friends who deserve the present. How many of these n × n sets of candies can be split equally into m parts without cutting a candy into pieces? Note that each set has to be split independently since the types of candies in different sets are different.
Input
The only line contains two integers n and m (1 ≤ n ≤ 10^9, 1 ≤ m ≤ 1000) — the size of the field and the number of parts to split the sets into.
Output
Print a single integer — the number of sets that can be split equally.
Examples
Input
3 3
Output
1
Input
6 5
Output
13
Input
1000000000 1
Output
1000000000000000000
Note
In the first example, only the set for cell (3, 3) can be split equally (3^2 + 3^2 = 18, which is divisible by m=3).
In the second example, the sets for the following cells can be divided equally:
* (1, 2) and (2, 1), since 1^2 + 2^2 = 5, which is divisible by 5;
* (1, 3) and (3, 1);
* (2, 4) and (4, 2);
* (2, 6) and (6, 2);
* (3, 4) and (4, 3);
* (3, 6) and (6, 3);
* (5, 5).
In the third example, sets in all cells can be divided equally, since m = 1.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
int main() {
int n, m;
cin >> n >> m;
long long ans = 0;
for (int i = 1; i <= m; i++) {
long long cnt = 0;
for (int j = 1; j <= m; j++) {
if ((i * i + j * j) % m == 0) {
cnt++;
}
}
cnt = cnt * (n / m);
for (long long j = (n / m) * m + 1; j <= n; j++) {
if ((i * i + j * j) % m == 0) {
cnt++;
}
}
ans += cnt;
}
ans = ans * (n / m);
for (long long i = (n / m) * m + 1; i <= n; i++) {
long long cnt = 0;
for (int j = 1; j <= m; j++) {
if ((i * i + j * j) % m == 0) {
cnt++;
}
}
cnt = cnt * (n / m);
for (long long j = (n / m) * m + 1; j <= n; j++) {
if ((i * i + j * j) % m == 0) {
cnt++;
}
}
ans += cnt;
}
cout << ans;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
Two children are playing tag on a number line. (In the game of tag, the child called "it" tries to catch the other child.) The child who is "it" is now at coordinate A, and he can travel the distance of V per second. The other child is now at coordinate B, and she can travel the distance of W per second.
He can catch her when his coordinate is the same as hers. Determine whether he can catch her within T seconds (including exactly T seconds later). We assume that both children move optimally.
Constraints
* -10^9 \leq A,B \leq 10^9
* 1 \leq V,W \leq 10^9
* 1 \leq T \leq 10^9
* A \neq B
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
A V
B W
T
Output
If "it" can catch the other child, print `YES`; otherwise, print `NO`.
Examples
Input
1 2
3 1
3
Output
YES
Input
1 2
3 2
3
Output
NO
Input
1 2
3 3
3
Output
NO
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main()
{
long long a,v,b,w,t;
scanf("%lld%lld%lld%lld%lld",&a,&v,&b,&w,&t);
if(v*t-w*t>=fabs(a-b))
printf("YES\n");
else printf("NO\n");
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
Please notice the unusual memory limit of this problem.
Orac likes games. Recently he came up with the new game, "Game of Life".
You should play this game on a black and white grid with n rows and m columns. Each cell is either black or white.
For each iteration of the game (the initial iteration is 0), the color of each cell will change under the following rules:
* If there are no adjacent cells with the same color as this cell on the current iteration, the color of it on the next iteration will be the same.
* Otherwise, the color of the cell on the next iteration will be different.
Two cells are adjacent if they have a mutual edge.
Now Orac has set an initial situation, and he wants to know for the cell (i,j) (in i-th row and j-th column), what will be its color at the iteration p. He may ask you these questions several times.
Input
The first line contains three integers n,m,t\ (1≤ n,m≤ 1000, 1≤ t≤ 100 000), representing the number of rows, columns, and the number of Orac queries.
Each of the following n lines contains a binary string of length m, the j-th character in i-th line represents the initial color of cell (i,j). '0' stands for white, '1' stands for black.
Each of the following t lines contains three integers i,j,p\ (1≤ i≤ n, 1≤ j≤ m, 1≤ p≤ 10^{18}), representing a query from Orac.
Output
Print t lines, in i-th line you should print the answer to the i-th query by Orac. If the color of this cell is black, you should print '1'; otherwise, you should write '0'.
Examples
Input
3 3 3
000
111
000
1 1 1
2 2 2
3 3 3
Output
1
1
1
Input
5 2 2
01
10
01
10
01
1 1 4
5 1 4
Output
0
0
Input
5 5 3
01011
10110
01101
11010
10101
1 1 4
1 2 3
5 5 3
Output
1
0
1
Input
1 1 3
0
1 1 1
1 1 2
1 1 3
Output
0
0
0
Note
<image>
For the first example, the picture above shows the initial situation and the color of cells at the iteration 1, 2, and 3. We can see that the color of (1,1) at the iteration 1 is black, the color of (2,2) at the iteration 2 is black, and the color of (3,3) at the iteration 3 is also black.
For the second example, you can prove that the cells will never change their colors.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
bool is_valid(long long i, long long j, vector<vector<bool> >& ma) {
if (i + 1 < ma.size() and ma[i][j] == ma[i + 1][j]) return true;
if (i > 0 and ma[i][j] == ma[i - 1][j]) return true;
if (j + 1 < ma[0].size() and ma[i][j] == ma[i][j + 1]) return true;
if (j > 0 and ma[i][j] == ma[i][j - 1]) return true;
return false;
}
void solve() {
long long n, m, t;
cin >> n >> m >> t;
vector<vector<bool> > ma(n, vector<bool>(m));
vector<vector<long long> > otro(n, vector<long long>(m, LLONG_MAX));
for (int i = 0; i < n; i++) {
string x;
cin >> x;
for (int j = 0; j < m; j++) {
ma[i][j] = x[j] == '0' ? 0 : 1;
}
}
queue<pair<long long, long long> > q;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (is_valid(i, j, ma)) {
otro[i][j] = 0;
q.push({i, j});
}
}
}
while (!q.empty()) {
pair<long long, long long> cur = q.front();
q.pop();
for (int i = -1; i < 2; i++) {
for (int j = -1; j < 2; j++) {
if ((i == 0 and j != 0) or (i != 0 and j == 0)) {
if (cur.first + i < n and cur.first + i > -1) {
if (cur.second + j < m and cur.second + j > -1) {
if (otro[cur.first][cur.second] + 1 <
otro[cur.first + i][cur.second + j]) {
otro[cur.first + i][cur.second + j] =
otro[cur.first][cur.second] + 1;
q.push(make_pair(cur.first + i, cur.second + j));
}
}
}
}
}
}
}
for (int i = 0; i < t; i++) {
long long x, y, p;
cin >> x >> y >> p;
x--;
y--;
if (otro[x][y] >= p or (p - otro[x][y]) % 2 == 0) {
cout << ma[x][y] << '\n';
} else {
cout << !ma[x][y] << '\n';
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
solve();
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
Polycarp watched TV-show where k jury members one by one rated a participant by adding him a certain number of points (may be negative, i. e. points were subtracted). Initially the participant had some score, and each the marks were one by one added to his score. It is known that the i-th jury member gave ai points.
Polycarp does not remember how many points the participant had before this k marks were given, but he remembers that among the scores announced after each of the k judges rated the participant there were n (n ≤ k) values b1, b2, ..., bn (it is guaranteed that all values bj are distinct). It is possible that Polycarp remembers not all of the scores announced, i. e. n < k. Note that the initial score wasn't announced.
Your task is to determine the number of options for the score the participant could have before the judges rated the participant.
Input
The first line contains two integers k and n (1 ≤ n ≤ k ≤ 2 000) — the number of jury members and the number of scores Polycarp remembers.
The second line contains k integers a1, a2, ..., ak ( - 2 000 ≤ ai ≤ 2 000) — jury's marks in chronological order.
The third line contains n distinct integers b1, b2, ..., bn ( - 4 000 000 ≤ bj ≤ 4 000 000) — the values of points Polycarp remembers. Note that these values are not necessarily given in chronological order.
Output
Print the number of options for the score the participant could have before the judges rated the participant. If Polycarp messes something up and there is no options, print "0" (without quotes).
Examples
Input
4 1
-5 5 0 20
10
Output
3
Input
2 2
-2000 -2000
3998000 4000000
Output
1
Note
The answer for the first example is 3 because initially the participant could have - 10, 10 or 15 points.
In the second example there is only one correct initial score equaling to 4 002 000.
### Response
```cpp
#include <bits/stdc++.h>
using std::vector;
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
int n, k;
std::cin >> k >> n;
vector<int> mark_ref(k);
for (auto& elem : mark_ref) {
std::cin >> elem;
}
vector<int> marks(n);
for (auto& elem : marks) {
std::cin >> elem;
}
vector<int> sum(k, 0);
sum[0] = mark_ref[0];
for (size_t i = 1; i < k; ++i) {
sum[i] = sum[i - 1] + mark_ref[i];
}
std::set<int> possible_values;
for (size_t i = 0; i < k; ++i) {
possible_values.insert(marks[0] - sum[i]);
}
size_t ans = 0;
for (auto it = possible_values.begin(); it != possible_values.end(); ++it) {
int cand = *it;
std::set<int> points;
for (size_t j = 0; j < k; ++j) {
points.insert(cand + sum[j]);
}
bool flag = true;
for (auto elem : marks) {
if (points.find(elem) == points.end()) {
flag = false;
break;
}
}
ans += (flag);
}
std::cout << ans;
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
Little Petya loves looking for numbers' divisors. One day Petya came across the following problem:
You are given n queries in the form "xi yi". For each query Petya should count how many divisors of number xi divide none of the numbers xi - yi, xi - yi + 1, ..., xi - 1. Help him.
Input
The first line contains an integer n (1 ≤ n ≤ 105). Each of the following n lines contain two space-separated integers xi and yi (1 ≤ xi ≤ 105, 0 ≤ yi ≤ i - 1, where i is the query's ordinal number; the numeration starts with 1).
If yi = 0 for the query, then the answer to the query will be the number of divisors of the number xi. In this case you do not need to take the previous numbers x into consideration.
Output
For each query print the answer on a single line: the number of positive integers k such that <image>
Examples
Input
6
4 0
3 1
5 2
6 2
18 4
10000 3
Output
3
1
1
2
2
22
Note
Let's write out the divisors that give answers for the first 5 queries:
1) 1, 2, 4
2) 3
3) 5
4) 2, 6
5) 9, 18
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<int> divi[100017];
set<int> st[100017];
int main() {
for (int i = 1; i <= 100007; i++) {
for (int j = i; j <= 100007; j += i) {
divi[j].push_back(i);
}
}
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int x, y;
scanf("%d%d", &x, &y);
int c = 0;
for (int j = 0; j < divi[x].size(); j++) {
int up = i - y;
if (st[divi[x][j]].lower_bound(up) == st[divi[x][j]].end()) c++;
st[divi[x][j]].insert(i);
}
cout << c << endl;
}
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
You are given two lists of segments [al_1, ar_1], [al_2, ar_2], ..., [al_n, ar_n] and [bl_1, br_1], [bl_2, br_2], ..., [bl_n, br_n].
Initially, all segments [al_i, ar_i] are equal to [l_1, r_1] and all segments [bl_i, br_i] are equal to [l_2, r_2].
In one step, you can choose one segment (either from the first or from the second list) and extend it by 1. In other words, suppose you've chosen segment [x, y] then you can transform it either into [x - 1, y] or into [x, y + 1].
Let's define a total intersection I as the sum of lengths of intersections of the corresponding pairs of segments, i.e. ∑_{i=1}^{n}{intersection_length([al_i, ar_i], [bl_i, br_i])}. Empty intersection has length 0 and length of a segment [x, y] is equal to y - x.
What is the minimum number of steps you need to make I greater or equal to k?
Input
The first line contains the single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and k (1 ≤ n ≤ 2 ⋅ 10^5; 1 ≤ k ≤ 10^9) — the length of lists and the minimum required total intersection.
The second line of each test case contains two integers l_1 and r_1 (1 ≤ l_1 ≤ r_1 ≤ 10^9) — the segment all [al_i, ar_i] are equal to initially.
The third line of each test case contains two integers l_2 and r_2 (1 ≤ l_2 ≤ r_2 ≤ 10^9) — the segment all [bl_i, br_i] are equal to initially.
It's guaranteed that the sum of n doesn't exceed 2 ⋅ 10^5.
Output
Print t integers — one per test case. For each test case, print the minimum number of step you need to make I greater or equal to k.
Example
Input
3
3 5
1 2
3 4
2 1000000000
1 1
999999999 999999999
10 3
5 10
7 8
Output
7
2000000000
0
Note
In the first test case, we can achieve total intersection 5, for example, using next strategy:
* make [al_1, ar_1] from [1, 2] to [1, 4] in 2 steps;
* make [al_2, ar_2] from [1, 2] to [1, 3] in 1 step;
* make [bl_1, br_1] from [3, 4] to [1, 4] in 2 steps;
* make [bl_2, br_2] from [3, 4] to [1, 4] in 2 steps.
In result, I = intersection_length([al_1, ar_1], [bl_1, br_1]) + intersection_length([al_2, ar_2], [bl_2, br_2]) + \\\ + intersection_length([al_3, ar_3], [bl_3, br_3]) = 3 + 2 + 0 = 5
In the second test case, we can make [al_1, ar_1] = [0, 1000000000] in 1000000000 steps and [bl_1, br_1] = [0, 1000000000] in 1000000000 steps.
In the third test case, the total intersection I is already equal to 10 > 3, so we don't need to do any steps.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long t, n, k, al, ar, bl, br;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> t;
while (t--) {
cin >> n >> k >> al >> ar >> bl >> br;
if (min(ar, br) >= max(al, bl)) {
k -= (min(ar, br) - max(al, bl)) * n;
}
if (k <= 0) {
cout << 0 << '\n';
continue;
}
long long prev_k = k;
if (min(ar, br) >= max(al, bl)) {
k -= (max(al, bl) - min(al, bl) + max(ar, br) - min(ar, br)) * n;
ar = max(br, ar);
br = ar;
bl = min(al, bl);
al = bl;
}
if (k <= 0) {
cout << prev_k << '\n';
continue;
}
long long needed = prev_k - k;
if (al == bl && br == ar) {
cout << needed + 2 * k << '\n';
continue;
}
for (int i = 1; i <= n; i++) {
long long pom = min(abs(bl - ar), abs(al - br));
long long pom2 = max(abs(br - al), abs(ar - bl));
if (i == 1) {
needed += pom;
needed += min(k, pom2);
k -= min(k, pom2);
} else {
if (k < pom) {
needed += 2 * k;
k = 0;
} else {
needed += pom;
needed += min(k, pom2);
k -= min(k, pom2);
}
}
if (k <= 0) break;
}
if (k == 0) {
cout << needed << '\n';
continue;
}
cout << needed + 2 * k << '\n';
}
return 0;
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
N people are standing in a queue, numbered 1, 2, 3, ..., N from front to back. Each person wears a hat, which is red, blue, or green.
The person numbered i says:
* "In front of me, exactly A_i people are wearing hats with the same color as mine."
Assuming that all these statements are correct, find the number of possible combinations of colors of the N people's hats.
Since the count can be enormous, compute it modulo 1000000007.
Constraints
* 1 \leq N \leq 100000
* 0 \leq A_i \leq N-1
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 A_3 ... A_N
Output
Print the number of possible combinations of colors of the N people's hats, modulo 1000000007.
Examples
Input
6
0 1 2 3 4 5
Output
3
Input
3
0 0 0
Output
6
Input
54
0 0 1 0 1 2 1 2 3 2 3 3 4 4 5 4 6 5 7 8 5 6 6 7 7 8 8 9 9 10 10 11 9 12 10 13 14 11 11 12 12 13 13 14 14 15 15 15 16 16 16 17 17 17
Output
115295190
### Response
```cpp
#include <iostream>
#include <string>
#include <vector>
typedef long long ll;
using namespace std;
int main() {
int n;
vector<int> hats(3,0);
ll ans = 1;
cin >> n;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
ll count = 0;
int last = 0;
for(int j = 0; j < 3; j++) {
if (hats[j] == a) {
count++;
last = j;
}
}
ans = (ans * count) % 1000000007LL;
hats[last]++;
}
cout << ans << endl;
return 0;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
Jeff's friends know full well that the boy likes to get sequences and arrays for his birthday. Thus, Jeff got sequence p1, p2, ..., pn for his birthday.
Jeff hates inversions in sequences. An inversion in sequence a1, a2, ..., an is a pair of indexes i, j (1 ≤ i < j ≤ n), such that an inequality ai > aj holds.
Jeff can multiply some numbers of the sequence p by -1. At that, he wants the number of inversions in the sequence to be minimum. Help Jeff and find the minimum number of inversions he manages to get.
Input
The first line contains integer n (1 ≤ n ≤ 2000). The next line contains n integers — sequence p1, p2, ..., pn (|pi| ≤ 105). The numbers are separated by spaces.
Output
In a single line print the answer to the problem — the minimum number of inversions Jeff can get.
Examples
Input
2
2 1
Output
0
Input
9
-2 0 -1 0 -1 2 1 0 -1
Output
6
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int mod = 1000000007;
int modul(int x) {
if (x >= 0) return x;
return -x;
}
struct mem {
int p;
int numb;
};
inline bool cmp(mem &a, mem &b) {
if (a.p == b.p) return a.numb < b.numb;
return a.p < b.p;
}
int c2(int x) { return (x * (x - 1)) / 2; }
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
a[i] = modul(a[i]);
}
int x, y, ans = 0;
for (int i = 0; i < n; ++i) {
x = 0;
y = 0;
for (int j = 0; j < i; ++j) {
if (a[j] > a[i]) x++;
if (a[j] > -a[i]) y++;
}
for (int j = i + 1; j < n; ++j) {
if (a[j] < a[i]) x++;
if (a[j] < -a[i]) y++;
}
if (y < x) a[i] = -a[i];
}
for (int i = 0; i < n; ++i)
for (int j = 0; j < i; ++j)
if (a[j] > a[i]) ++ans;
cout << ans << endl;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
Farmer John is obsessed with making Bessie exercise more!
Bessie is out grazing on the farm, which consists of n fields connected by m directed roads. Each road takes some time w_i to cross. She is currently at field 1 and will return to her home at field n at the end of the day.
Farmer John has plans to increase the time it takes to cross certain roads. He can increase the time it takes to cross each road by a nonnegative amount, but the total increase cannot exceed x_i for the i-th plan.
Determine the maximum he can make the shortest path from 1 to n for each of the q independent plans.
Input
The first line contains integers n and m (2 ≤ n ≤ 50, 1 ≤ m ≤ n ⋅ (n-1)) — the number of fields and number of roads, respectively.
Each of the following m lines contains 3 integers, u_i, v_i, and w_i (1 ≤ u_i, v_i ≤ n, 1 ≤ w_i ≤ 10^6), meaning there is an road from field u_i to field v_i that takes w_i time to cross.
It is guaranteed that there exists a way to get to field n from field 1. It is guaranteed that the graph does not contain self-loops or parallel edges. It is possible to have a road from u to v and a road from v to u.
The next line contains a single integer q (1 ≤ q ≤ 10^5), the number of plans.
Each of the following q lines contains a single integer x_i, the query (0 ≤ x_i ≤ 10^5).
Output
For each query, output the maximum Farmer John can make the shortest path if the total increase does not exceed x_i.
Your answer is considered correct if its absolute or relative error does not exceed 10^{-6}.
Formally, let your answer be a, and the jury's answer be b. Your answer is accepted if and only if \frac{|a - b|}{max{(1, |b|)}} ≤ 10^{-6}.
Example
Input
3 3
1 2 2
2 3 2
1 3 3
5
0
1
2
3
4
Output
3.0000000000
4.0000000000
4.5000000000
5.0000000000
5.5000000000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
struct edge {
int t, nxt, f, c;
} e[5010];
int n, m, Q, u, v, w, be[55], cnt, sz, fv[2510], fl[2510], dis[55], iq[55],
ls[55], fe[55], t, lf;
double l, r, mid;
long long sv[2510];
queue<int> q;
void add(const int& x, const int& y, const int& fl, const int& cs) {
e[++cnt] = (edge){y, be[x], fl, cs}, be[x] = cnt;
}
bool SPFA() {
for (int i = 2; i <= n; ++i) dis[i] = INF;
q.push(1), iq[1] = 1;
while (!q.empty()) {
iq[t = q.front()] = 0, q.pop();
for (int i = be[t]; i; i = e[i].nxt)
if (e[i].f && dis[e[i].t] > dis[t] + e[i].c) {
dis[e[i].t] = dis[t] + e[i].c, ls[e[i].t] = t, fe[e[i].t] = i;
if (!iq[e[i].t]) q.push(e[i].t), iq[e[i].t] = 1;
}
}
if (dis[n] >= INF) return false;
t = 0, lf = INF;
for (int i = n; i != 1; i = ls[i]) lf = min(lf, e[fe[i]].f);
for (int i = n; i != 1; i = ls[i])
e[fe[i]].f -= lf, e[(fe[i] & 1 ? fe[i] + 1 : fe[i] - 1)].f += lf,
t += e[fe[i]].c;
if (!sz || fv[sz] != t)
fv[++sz] = t, sv[sz] = sv[sz - 1] + lf * t, fl[sz] = fl[sz - 1] + lf;
else
sv[sz] += lf * t, fl[sz] += lf;
return true;
}
bool Check(double x) {
int tl = 1, tr = sz, tm;
while (tl < tr) tm = tl + tr + 1 >> 1, fv[tm] < x ? tl = tm : tr = tm - 1;
return fl[tl] * x - sv[tl] <= w;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; ++i)
scanf("%d%d%d", &u, &v, &w), add(u, v, 1, w), add(v, u, 0, -w);
while (SPFA())
;
scanf("%d", &Q);
while (Q--) {
scanf("%d", &w);
l = 1, r = 1e26;
while (r - l > 1e-7) mid = (l + r) / 2.0, Check(mid) ? l = mid : r = mid;
printf("%.10lf\n", l);
}
return 0;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
You are given a string S. Each character of S is uppercase or lowercase English letter. Determine if S satisfies all of the following conditions:
* The initial character of S is an uppercase `A`.
* There is exactly one occurrence of `C` between the third character from the beginning and the second to last character (inclusive).
* All letters except the `A` and `C` mentioned above are lowercase.
Constraints
* 4 ≤ |S| ≤ 10 (|S| is the length of the string S.)
* Each character of S is uppercase or lowercase English letter.
Input
Input is given from Standard Input in the following format:
S
Output
If S satisfies all of the conditions in the problem statement, print `AC`; otherwise, print `WA`.
Examples
Input
AtCoder
Output
AC
Input
ACoder
Output
WA
Input
AcycliC
Output
WA
Input
AtCoCo
Output
WA
Input
Atcoder
Output
WA
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string s,ans="AC";
bool c=false;
cin >> s;
if(s[0]!='A') ans="WA";
for(long i=1;i<s.size();i++) {
if(s[i]=='C') {
if((i==1||i==s.size()-1)||c) ans="WA";
c=true;
} else if(s[i]<'a') {
ans="WA";
}
}
if(!c) ans="WA";
cout << ans << endl;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
The company X has n employees numbered from 1 through n. Each employee u has a direct boss p_u (1 ≤ p_u ≤ n), except for the employee 1 who has no boss. It is guaranteed, that values p_i form a tree. Employee u is said to be in charge of employee v if u is the direct boss of v or there is an employee w such that w is in charge of v and u is the direct boss of w. Also, any employee is considered to be in charge of himself.
In addition, for each employee u we define it's level lv(u) as follow:
* lv(1)=0
* lv(u)=lv(p_u)+1 for u ≠ 1
In the near future, there are q possible plans for the company to operate. The i-th plan consists of two integers l_i and r_i, meaning that all the employees in the range [l_i, r_i], and only they, are involved in this plan. To operate the plan smoothly, there must be a project manager who is an employee in charge of all the involved employees. To be precise, if an employee u is chosen as the project manager for the i-th plan then for every employee v ∈ [l_i, r_i], u must be in charge of v. Note, that u is not necessary in the range [l_i, r_i]. Also, u is always chosen in such a way that lv(u) is as large as possible (the higher the level is, the lower the salary that the company has to pay the employee).
Before any plan is operated, the company has JATC take a look at their plans. After a glance, he tells the company that for every plan, it's possible to reduce the number of the involved employees exactly by one without affecting the plan. Being greedy, the company asks JATC which employee they should kick out of the plan so that the level of the project manager required is as large as possible. JATC has already figured out the answer and challenges you to do the same.
Input
The first line contains two integers n and q (2 ≤ n ≤ 100 000, 1 ≤ q ≤ 100 000) — the number of employees and the number of plans, respectively.
The second line contains n-1 integers p_2, p_3, ..., p_n (1 ≤ p_i ≤ n) meaning p_i is the direct boss of employee i.
It is guaranteed, that values p_i form a directed tree with the root of 1.
Each of the following q lines contains two integers l_i and r_i (1 ≤ l_i<r_i ≤ n) — the range of the employees, involved in the corresponding plan.
Output
Print q lines, each containing two integers — the number of the employee which should be kicked from the corresponding plan and the maximum possible level of the project manager in that case.
If there are more than one way to choose that employee, print any of them.
Example
Input
11 5
1 1 3 3 3 4 2 7 7 6
4 6
4 8
1 11
9 11
8 11
Output
4 1
8 1
1 0
11 3
8 1
Note
In the example:
<image> In the first query, we can choose whether 4 or 5 or 6 and the project manager will be 3.
In the second query, if we choose any employee other than the employee 8, the project manager will be 1. If we choose 8, the project manager will be 3. Since lv(3)=1 > lv(1)=0, choosing 8 is the best strategy.
In the third query, no matter how we choose the employee, the project manager will always be 1.
In the fourth query, if we choose 9 or 10 then the project manager will be 3. If we choose 11 then the project manager will be 7. Since lv(7)=3>lv(3)=1, we choose 11 as the answer.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
inline int readint() {
int a = 0;
char c = getchar(), f = 1;
for (; c < '0' || c > '9'; c = getchar())
if (c == '-') f = -f;
for (; '0' <= c && c <= '9'; c = getchar())
a = (a << 3) + (a << 1) + (c ^ 48);
return a * f;
}
const int MaxN = 100005;
int n, m;
struct Edge {
int to, nxt;
Edge() {}
Edge(int T, int N) { to = T, nxt = N; }
};
Edge e[MaxN << 1];
int cntEdge, head[MaxN];
void clear_graph() {
for (int i = 1; i <= n; ++i) head[i] = -1;
cntEdge = 0;
}
void addEdge(int a, int b) {
e[cntEdge] = Edge(b, head[a]);
head[a] = cntEdge++;
}
int dep[MaxN];
int fa[MaxN][20];
int dfn[MaxN], dfsClock;
void build(int x, int pre = 0) {
dfn[x] = ++dfsClock;
dep[x] = dep[pre] + 1;
fa[x][0] = pre;
for (int j = 0; j + 1 < 20; ++j) {
if (fa[x][j] == 0) break;
fa[x][j + 1] = fa[fa[x][j]][j];
}
for (int i = head[x]; ~i; i = e[i].nxt)
if (e[i].to != pre) build(e[i].to, x);
}
int getLca(int a, int b) {
if (!a || !b) return a + b;
if (dep[a] < dep[b]) swap(a, b);
for (int j = 19; ~j; --j)
if ((dep[a] - dep[b]) >> j & 1) a = fa[a][j];
if (a == b) return a;
for (int j = 19; ~j; --j)
if (fa[a][j] != fa[b][j]) a = fa[a][j], b = fa[b][j];
return fa[a][0];
}
namespace UFS {
int fa[MaxN], rnk[MaxN];
int val[MaxN];
void init() {
for (int i = 1; i <= n; ++i) {
fa[i] = val[i] = i;
rnk[i] = 1;
}
}
inline int find(int a) {
if (a != fa[a]) fa[a] = find(fa[a]);
return fa[a];
}
void combine(int a, int b) {
a = find(a), b = find(b);
if (rnk[a] > rnk[b]) swap(a, b);
if (dep[val[a]] < dep[val[b]]) val[b] = val[a];
fa[a] = b, rnk[b] += rnk[a];
}
} // namespace UFS
vector<int> q[MaxN];
bool vis[MaxN];
void tarjan(int x, int pre = 0) {
for (int i = head[x]; ~i; i = e[i].nxt)
if (e[i].to != pre) {
tarjan(e[i].to, x);
UFS::combine(e[i].to, x);
}
vis[x] = true;
int len = q[x].size();
for (int i = 0, y; i < len; ++i)
if (vis[y = q[x][i]]) {
y = UFS::find(y);
q[x][i] = UFS::val[y];
} else
q[x][i] = -1;
}
int lca[20][MaxN], lg2[MaxN];
int st1[20][MaxN];
int st2[20][MaxN];
void prepare() {
lg2[1] = 0;
for (int i = 2; i <= n; ++i) lg2[i] = lg2[i >> 1] + 1;
for (int i = 1; i <= n; ++i) {
st1[0][i] = st2[0][i] = i;
lca[0][i] = i;
}
for (int j = 1; (1 << j) <= n; ++j) {
int len = (1 << j >> 1);
for (int i = 1; i + len * 2 - 1 <= n; ++i) {
int a = lca[j - 1][i];
int b = lca[j - 1][i + len];
q[a].push_back(b);
q[b].push_back(a);
a = st1[j - 1][i];
b = st1[j - 1][i + len];
if (dfn[a] < dfn[b])
st1[j][i] = a;
else
st1[j][i] = b;
a = st2[j - 1][i];
b = st2[j - 1][i + len];
if (dfn[a] > dfn[b])
st2[j][i] = a;
else
st2[j][i] = b;
}
for (int i = 1; i <= n; ++i) vis[i] = false;
UFS::init();
tarjan(1);
for (int i = n - len * 2 + 1; i; --i) {
int a = lca[j - 1][i];
int b = lca[j - 1][i + len];
if (q[a].back() != -1)
lca[j][i] = q[a].back();
else
lca[j][i] = q[b].back();
q[a].pop_back();
q[b].pop_back();
}
}
}
int queryLca(int l, int r) {
if (l > r) return 0;
int k = lg2[r - l + 1];
if ((1 << k) == r - l + 1) return lca[k][l];
return getLca(lca[k][l], lca[k][r - (1 << k) + 1]);
}
pair<int, int> queryDfn(int l, int r) {
pair<int, int> res;
int k = lg2[r - l + 1], a, b;
a = st1[k][l];
b = st1[k][r - (1 << k) + 1];
if (dfn[a] > dfn[b]) a = b;
res.first = a;
a = st2[k][l];
b = st2[k][r - (1 << k) + 1];
if (dfn[a] < dfn[b]) a = b;
res.second = a;
return res;
}
int main() {
n = readint(), m = readint();
clear_graph();
for (int i = 2; i <= n; ++i) addEdge(readint(), i);
build(1), prepare();
for (int l, r; m; --m) {
l = readint(), r = readint();
auto away = queryDfn(l, r);
int xjh = queryLca(l, away.first - 1);
xjh = getLca(xjh, queryLca(away.first + 1, r));
int xez = queryLca(l, away.second - 1);
xez = getLca(xez, queryLca(away.second + 1, r));
if (dep[xjh] < dep[xez]) xjh = xez, away.first = away.second;
printf("%d %d\n", away.first, dep[xjh] - 1);
}
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
You are given two strings x and y, both consist only of lowercase Latin letters. Let |s| be the length of string s.
Let's call a sequence a a merging sequence if it consists of exactly |x| zeros and exactly |y| ones in some order.
A merge z is produced from a sequence a by the following rules:
* if a_i=0, then remove a letter from the beginning of x and append it to the end of z;
* if a_i=1, then remove a letter from the beginning of y and append it to the end of z.
Two merging sequences a and b are different if there is some position i such that a_i ≠ b_i.
Let's call a string z chaotic if for all i from 2 to |z| z_{i-1} ≠ z_i.
Let s[l,r] for some 1 ≤ l ≤ r ≤ |s| be a substring of consecutive letters of s, starting from position l and ending at position r inclusive.
Let f(l_1, r_1, l_2, r_2) be the number of different merging sequences of x[l_1,r_1] and y[l_2,r_2] that produce chaotic merges. Note that only non-empty substrings of x and y are considered.
Calculate ∑ _{1 ≤ l_1 ≤ r_1 ≤ |x| \\\ 1 ≤ l_2 ≤ r_2 ≤ |y|} f(l_1, r_1, l_2, r_2). Output the answer modulo 998 244 353.
Input
The first line contains a string x (1 ≤ |x| ≤ 1000).
The second line contains a string y (1 ≤ |y| ≤ 1000).
Both strings consist only of lowercase Latin letters.
Output
Print a single integer — the sum of f(l_1, r_1, l_2, r_2) over 1 ≤ l_1 ≤ r_1 ≤ |x| and 1 ≤ l_2 ≤ r_2 ≤ |y| modulo 998 244 353.
Examples
Input
aaa
bb
Output
24
Input
code
forces
Output
1574
Input
aaaaa
aaa
Output
0
Input
justamassivetesttocheck
howwellyouhandlemodulooperations
Output
667387032
Note
In the first example there are:
* 6 pairs of substrings "a" and "b", each with valid merging sequences "01" and "10";
* 3 pairs of substrings "a" and "bb", each with a valid merging sequence "101";
* 4 pairs of substrings "aa" and "b", each with a valid merging sequence "010";
* 2 pairs of substrings "aa" and "bb", each with valid merging sequences "0101" and "1010";
* 2 pairs of substrings "aaa" and "b", each with no valid merging sequences;
* 1 pair of substrings "aaa" and "bb" with a valid merging sequence "01010";
Thus, the answer is 6 ⋅ 2 + 3 ⋅ 1 + 4 ⋅ 1 + 2 ⋅ 2 + 2 ⋅ 0 + 1 ⋅ 1 = 24.
### Response
```cpp
#include <bits/stdc++.h>
#define ll long long
#define pb push_back
#define mem(x, y) memset(& x, y, sizeof(x))
#define all(x) begin(x), end(x)
#define SZ(x) (int)(x).size()
using namespace std;
const int n0=1003,mod=998244353;
int bp(int x,int y) {
int res=1;
while(y) {
if(y&1) res=(ll)res*x%mod;
x=(ll)x*x%mod;
y/=2;
}
return res;
}
struct mint {
int x;
mint(int _x=0) {
x=_x;
}
void operator += (mint a) {
x+=a.x;
if(x>=mod) x-=mod;
}
void operator -= (mint a) {
x-=a.x;
if(x<0) x+=mod;
}
void operator *= (mint a) {
x=(ll)x*a.x%mod;
}
void operator /= (mint a) {
x=(ll)x*bp(a.x,mod-2)%mod;
}
mint operator + (mint a) {
mint res=*this;
res+=a;
return res;
}
mint operator - (mint a) {
mint res=*this;
res-=a;
return res;
}
mint operator * (mint a) {
mint res=*this;
res*=a;
return res;
}
mint operator / (mint a) {
mint res=*this;
res/=a;
return res;
}
};
int n,m;
mint dp[n0][n0][2];
string a,b;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> a >> b;
n=SZ(a),m=SZ(b);
mint ans=0;
for(int i=0; i<=n; i++) {
for(int j=0; j<=m; j++) {
if(i) {
dp[i][j][0]=1;
if(i-2<0 || a[i-1]!=a[i-2]) {
dp[i][j][0]+=dp[i-1][j][0];
}
if(j-1<0 || a[i-1]!=b[j-1]) {
dp[i][j][0]+=dp[i-1][j][1];
}
}
if(j) {
dp[i][j][1]=1;
if(j-2<0 || b[j-1]!=b[j-2]) {
dp[i][j][1]+=dp[i][j-1][1];
}
if(i-1<0 || b[j-1]!=a[i-1]) {
dp[i][j][1]+=dp[i][j-1][0];
}
}
ans+=dp[i][j][0]+dp[i][j][1];
}
}
for(int i=1; i<=n; i++) {
for(int j=i; j<=n; j++) {
if(j>i && a[j-1]==a[j-2]) break;
ans-=m+1;
}
}
for(int i=1; i<=m; i++) {
for(int j=i; j<=m; j++) {
if(j>i && b[j-1]==b[j-2]) break;
ans-=n+1;
}
}
cout << ans.x;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
RedDreamer has an array a consisting of n non-negative integers, and an unlucky integer T.
Let's denote the misfortune of array b having length m as f(b) — the number of pairs of integers (i, j) such that 1 ≤ i < j ≤ m and b_i + b_j = T. RedDreamer has to paint each element of a into one of two colors, white and black (for each element, the color is chosen independently), and then create two arrays c and d so that all white elements belong to c, and all black elements belong to d (it is possible that one of these two arrays becomes empty). RedDreamer wants to paint the elements in such a way that f(c) + f(d) is minimum possible.
For example:
* if n = 6, T = 7 and a = [1, 2, 3, 4, 5, 6], it is possible to paint the 1-st, the 4-th and the 5-th elements white, and all other elements black. So c = [1, 4, 5], d = [2, 3, 6], and f(c) + f(d) = 0 + 0 = 0;
* if n = 3, T = 6 and a = [3, 3, 3], it is possible to paint the 1-st element white, and all other elements black. So c = [3], d = [3, 3], and f(c) + f(d) = 0 + 1 = 1.
Help RedDreamer to paint the array optimally!
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases. Then t test cases follow.
The first line of each test case contains two integers n and T (1 ≤ n ≤ 10^5, 0 ≤ T ≤ 10^9) — the number of elements in the array and the unlucky integer, respectively.
The second line contains n integers a_1, a_2, ..., a_n (0 ≤ a_i ≤ 10^9) — the elements of the array.
The sum of n over all test cases does not exceed 10^5.
Output
For each test case print n integers: p_1, p_2, ..., p_n (each p_i is either 0 or 1) denoting the colors. If p_i is 0, then a_i is white and belongs to the array c, otherwise it is black and belongs to the array d.
If there are multiple answers that minimize the value of f(c) + f(d), print any of them.
Example
Input
2
6 7
1 2 3 4 5 6
3 6
3 3 3
Output
1 0 0 1 1 0
1 0 0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long int INF = 1000000007;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t, i, j;
cin >> t;
while (t--) {
long long int n, k;
cin >> n >> k;
long long int arr[n];
unordered_map<long long int, long long int> hash;
for (i = 0; i < n; i++) {
cin >> arr[i];
hash[arr[i]]++;
}
unordered_map<long long int, long long int> ans;
unordered_map<long long int, long long int> vis;
for (i = 0; i < n; i++) {
long long int b = k - arr[i];
if (b == arr[i]) {
vis[arr[i]] = 1;
} else if (ans[arr[i]] == 0 && b >= 0) {
ans[arr[i]] = -1;
ans[b] = 1;
}
}
for (i = 0; i < n; i++) {
if (vis[arr[i]] > 0) {
if (vis[arr[i]] % 2 == 0)
cout << 0 << " ";
else
cout << 1 << " ";
vis[arr[i]]++;
} else if (ans[arr[i]] == 1)
cout << 0 << " ";
else if (ans[arr[i]] == -1)
cout << 1 << " ";
else
cout << 0 << " ";
}
cout << endl;
}
return 0;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
Most C/C++ programmers know about excellent opportunities that preprocessor #define directives give; but many know as well about the problems that can arise because of their careless use.
In this problem we consider the following model of #define constructions (also called macros). Each macro has its name and value. The generic syntax for declaring a macro is the following:
#define macro_name macro_value
After the macro has been declared, "macro_name" is replaced with "macro_value" each time it is met in the program (only the whole tokens can be replaced; i.e. "macro_name" is replaced only when it is surrounded by spaces or other non-alphabetic symbol). A "macro_value" within our model can only be an arithmetic expression consisting of variables, four arithmetic operations, brackets, and also the names of previously declared macros (in this case replacement is performed sequentially). The process of replacing macros with their values is called substitution.
One of the main problems arising while using macros — the situation when as a result of substitution we get an arithmetic expression with the changed order of calculation because of different priorities of the operations.
Let's consider the following example. Say, we declared such a #define construction:
#define sum x + y
and further in the program the expression "2 * sum" is calculated. After macro substitution is performed we get "2 * x + y", instead of intuitively expected "2 * (x + y)".
Let's call the situation "suspicious", if after the macro substitution the order of calculation changes, falling outside the bounds of some macro. Thus, your task is to find out by the given set of #define definitions and the given expression if this expression is suspicious or not.
Let's speak more formally. We should perform an ordinary macros substitution in the given expression. Moreover, we should perform a "safe" macros substitution in the expression, putting in brackets each macro value; after this, guided by arithmetic rules of brackets expansion, we can omit some of the brackets. If there exist a way to get an expression, absolutely coinciding with the expression that is the result of an ordinary substitution (character-by-character, but ignoring spaces), then this expression and the macros system are called correct, otherwise — suspicious.
Note that we consider the "/" operation as the usual mathematical division, not the integer division like in C/C++. That's why, for example, in the expression "a*(b/c)" we can omit brackets to get the expression "a*b/c".
Input
The first line contains the only number n (0 ≤ n ≤ 100) — the amount of #define constructions in the given program.
Then there follow n lines, each of them contains just one #define construction. Each construction has the following syntax:
#define name expression
where
* name — the macro name,
* expression — the expression with which the given macro will be replaced. An expression is a non-empty string, containing digits,names of variables, names of previously declared macros, round brackets and operational signs +-*/. It is guaranteed that the expression (before and after macros substitution) is a correct arithmetic expression, having no unary operations. The expression contains only non-negative integers, not exceeding 109.
All the names (#define constructions' names and names of their arguments) are strings of case-sensitive Latin characters. It is guaranteed that the name of any variable is different from any #define construction.
Then, the last line contains an expression that you are to check. This expression is non-empty and satisfies the same limitations as the expressions in #define constructions.
The input lines may contain any number of spaces anywhere, providing these spaces do not break the word "define" or the names of constructions and variables. In particular, there can be any number of spaces before and after the "#" symbol.
The length of any line from the input file does not exceed 100 characters.
Output
Output "OK", if the expression is correct according to the above given criterion, otherwise output "Suspicious".
Examples
Input
1
#define sum x + y
1 * sum
Output
Suspicious
Input
1
#define sum (x + y)
sum - sum
Output
OK
Input
4
#define sum x + y
#define mul a * b
#define div a / b
#define expr sum + mul * div * mul
expr
Output
OK
Input
3
#define SumSafe (a+b)
#define DivUnsafe a/b
#define DenominatorUnsafe a*b
((SumSafe) + DivUnsafe/DivUnsafe + x/DenominatorUnsafe)
Output
Suspicious
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void ckmax(T& x, T y) {
x = (y > x ? y : x);
}
template <typename T>
inline void ckmin(T& x, T y) {
x = (y < x ? y : x);
}
char arr[1 << 20];
char* p;
string str;
void get_nxt() {
while (*p == ' ' && *p != 0) {
++p;
}
if (*p == 0) {
str = "";
} else {
if (isalpha(*p) || isdigit(*p)) {
str = "";
do {
str += *p++;
} while (isalpha(*p) || isdigit(*p));
} else {
str = "";
str += *p++;
}
}
}
map<string, char> macros;
char add();
char mult();
char get_expr() {
char res = add();
while (str == "+" || str == "-") {
char op = str[0];
get_nxt();
char ch = add();
if (res == 'x' || ch == 'x') {
res = 'x';
} else if (op == '-' && ch == '+') {
res = 'x';
} else {
res = '+';
}
}
return res;
}
char add() {
char res = mult();
while (str == "*" || str == "/") {
char op = str[0];
get_nxt();
char ch = mult();
if (res == 'x' || ch == 'x') {
res = 'x';
} else if (res == '+' || ch == '+') {
res = 'x';
} else if (op == '/' && ch == '*') {
res = 'x';
} else {
res = '*';
}
}
return res;
}
char mult() {
if (str == "(") {
get_nxt();
char res = get_expr();
get_nxt();
if (res != 'x') {
res = ' ';
}
return res;
}
if (!macros.count(str)) {
get_nxt();
return ' ';
}
string name = str;
get_nxt();
return macros[name];
}
int main() {
gets(arr);
int n;
sscanf(arr, "%d", &n);
while (n--) {
gets(arr);
p = arr;
get_nxt();
get_nxt();
get_nxt();
string name = str;
get_nxt();
macros[name] = get_expr();
}
gets(arr);
p = arr;
get_nxt();
char res = get_expr();
if (res == 'x') {
puts("Suspicious");
} else {
puts("OK");
}
return 0;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
Given is a positive integer N. Consider repeatedly applying the operation below on N:
* First, choose a positive integer z satisfying all of the conditions below:
* z can be represented as z=p^e, where p is a prime number and e is a positive integer;
* z divides N;
* z is different from all integers chosen in previous operations.
* Then, replace N with N/z.
Find the maximum number of times the operation can be applied.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^{12}
Input
Input is given from Standard Input in the following format:
N
Output
Print the maximum number of times the operation can be applied.
Examples
Input
24
Output
3
Input
1
Output
0
Input
64
Output
3
Input
1000000007
Output
1
Input
997764507000
Output
7
### Response
```cpp
#include<iostream>
using namespace std;
int main(){
long long int N;
cin >> N;
int ans = 0;
for(int i=2;i<1000010;i++){
int cur = 0;
while (N % i == 0) {
cur++;
N /= i;
}
for(int j=1;j<=cur;j++) {
ans++; cur -= j;
}
}
if(N>1) ans++;
cout << ans << endl;
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
Genos and Saitama went shopping for Christmas trees. However, a different type of tree caught their attention, the exalted Power Tree.
A Power Tree starts out as a single root vertex indexed 1. A Power Tree grows through a magical phenomenon known as an update. In an update, a single vertex is added to the tree as a child of some other vertex.
Every vertex in the tree (the root and all the added vertices) has some value vi associated with it. The power of a vertex is defined as the strength of the multiset composed of the value associated with this vertex (vi) and the powers of its direct children. The strength of a multiset is defined as the sum of all elements in the multiset multiplied by the number of elements in it. Or in other words for some multiset S:
<image>
Saitama knows the updates that will be performed on the tree, so he decided to test Genos by asking him queries about the tree during its growth cycle.
An update is of the form 1 p v, and adds a new vertex with value v as a child of vertex p.
A query is of the form 2 u, and asks for the power of vertex u.
Please help Genos respond to these queries modulo 109 + 7.
Input
The first line of the input contains two space separated integers v1 and q (1 ≤ v1 < 109, 1 ≤ q ≤ 200 000) — the value of vertex 1 and the total number of updates and queries respectively.
The next q lines contain the updates and queries. Each of them has one of the following forms:
* 1 pi vi, if these line describes an update. The index of the added vertex is equal to the smallest positive integer not yet used as an index in the tree. It is guaranteed that pi is some already existing vertex and 1 ≤ vi < 109.
* 2 ui, if these line describes a query. It is guaranteed ui will exist in the tree.
It is guaranteed that the input will contain at least one query.
Output
For each query, print out the power of the given vertex modulo 109 + 7.
Examples
Input
2 5
1 1 3
1 2 5
1 3 7
1 4 11
2 1
Output
344
Input
5 5
1 1 4
1 2 3
2 2
1 2 7
2 1
Output
14
94
Note
For the first sample case, after all the updates the graph will have vertices labelled in the following manner: 1 — 2 — 3 — 4 — 5
These vertices will have corresponding values: 2 — 3 — 5 — 7 — 11
And corresponding powers: 344 — 170 — 82 — 36 — 11
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int off = 1 << 18;
const int MOD = 1e9 + 7;
int q, n = 1;
int st[off << 1] = {}, sp[off], st2[off << 1];
vector<int> g[200001];
int qt[200000], qv[200000], qval[200000], ch[200001] = {};
int tin[200001], tout[200001], timer = -1, par[200001];
void dfs(int v) {
tin[v] = ++timer;
for (int to : g[v]) {
dfs(to);
}
tout[v] = timer;
}
void stBuild() {
for (int i = off - 1; i >= 1; --i) {
st[i] = st[2 * i] + st[2 * i + 1];
sp[i] = 1;
}
for (int i = 0; i < (int)(2 * off); ++i) st2[i] = 1;
}
void stPush(int v) {
for (int i = 2 * v; i <= 2 * v + 1; ++i) {
st[i] = (long long)st[i] * sp[v] % MOD;
if (i < off) {
sp[i] = (long long)sp[i] * sp[v] % MOD;
}
}
sp[v] = 1;
}
int mul;
void stMul(int v, int L, int R, int l, int r) {
if (L == l && R == r) {
st[v] = (long long)st[v] * mul % MOD;
if (L != R) sp[v] = (long long)sp[v] * mul % MOD;
return;
}
int mid = (L + R) >> 1;
if (sp[v] != 1) {
stPush(v);
}
if (l <= mid) stMul(2 * v, L, mid, l, min(r, mid));
if (r > mid) stMul(2 * v + 1, mid + 1, R, max(l, mid + 1), r);
st[v] = st[2 * v] + st[2 * v + 1];
if (st[v] >= MOD) st[v] -= MOD;
}
int pos, val;
void stAssign(int v, int L, int R) {
if (L == R) {
st[v] = val;
return;
}
int mid = (L + R) >> 1;
if (sp[v] != 1) {
stPush(v);
}
if (pos <= mid)
stAssign(2 * v, L, mid);
else
stAssign(2 * v + 1, mid + 1, R);
st[v] = st[2 * v] + st[2 * v + 1];
if (st[v] >= MOD) st[v] -= MOD;
}
int stGet(int v, int L, int R, int l, int r) {
if (l > r) return 0;
if (L == l && R == r) {
return st[v];
}
int mid = (L + R) >> 1;
if (sp[v] != 1) {
stPush(v);
}
int res = stGet(2 * v, L, mid, l, min(r, mid)) +
stGet(2 * v + 1, mid + 1, R, max(l, mid + 1), r);
if (res >= MOD) res -= MOD;
return res;
}
void st2Mul(int v, int L, int R, int l, int r) {
if (L == l && R == r) {
st2[v] = (long long)st2[v] * mul % MOD;
return;
}
int mid = (L + R) >> 1;
if (l <= mid) st2Mul(2 * v, L, mid, l, min(r, mid));
if (r > mid) st2Mul(2 * v + 1, mid + 1, R, max(l, mid + 1), r);
}
int st2Get(int pos) {
int res = 1;
for (pos += off; pos >= 1; pos >>= 1) {
res = (long long)res * st2[pos] % MOD;
}
return res;
}
int binPow(long long x, int p) {
long long res = 1;
while (p) {
if (p & 1) res = res * x % MOD;
p >>= 1;
if (p) x = x * x % MOD;
}
return (int)res;
}
int main() {
scanf("%d%d", st + off, &q);
for (int i = 0; i < (int)(q); ++i) {
scanf("%d%d", qt + i, qv + i), --qv[i];
if (qt[i] == 1) {
scanf("%d", qval + i);
g[qv[i]].push_back(n);
par[n++] = qv[i];
}
}
dfs(0);
stBuild();
n = 1;
for (int i = 0; i < (int)(q); ++i) {
if (qt[i] == 1) {
val = (long long)st2Get(tin[qv[i]]) * qval[i] % MOD;
pos = tin[n++];
stAssign(1, 0, off - 1);
mul = (long long)(ch[qv[i]] + 2) * binPow(ch[qv[i]] + 1, MOD - 2) % MOD;
++ch[qv[i]];
stMul(1, 0, off - 1, tin[qv[i]], tout[qv[i]]);
st2Mul(1, 0, off - 1, tin[qv[i]], tout[qv[i]]);
} else {
int res = stGet(1, 0, off - 1, tin[qv[i]], tout[qv[i]]);
if (qv[i] != 0) {
res = (long long)res * binPow(st2Get(tin[par[qv[i]]]), MOD - 2) % MOD;
}
printf("%d\n", res);
}
}
return 0;
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
Nicholas, a painter is going to paint several new canvases. Nicholas is sure that the canvases will turn out so great that each one will need framing and being hung on the wall. Frames are what Nicholas decided to begin with.
Nicholas has n sticks whose lengths equal a1, a2, ... an. Nicholas does not want to break the sticks or glue them together. To make a h × w-sized frame, he needs two sticks whose lengths equal h and two sticks whose lengths equal w. Specifically, to make a square frame (when h = w), he needs four sticks of the same length.
Now Nicholas wants to make from the sticks that he has as many frames as possible; to be able to paint as many canvases as possible to fill the frames. Help him in this uneasy task. Note that it is not necessary to use all the sticks Nicholas has.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the number of sticks. The second line contains n space-separated integers. The i-th integer equals the length of the i-th stick ai (1 ≤ ai ≤ 100).
Output
Print the single number — the maximum number of frames Nicholas can make for his future canvases.
Examples
Input
5
2 4 3 2 3
Output
1
Input
13
2 2 4 4 4 4 6 6 6 7 7 9 9
Output
3
Input
4
3 3 3 5
Output
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, a[100000], ans;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
a[x]++;
}
for (int i = 1; i <= 10000; i++) {
if (a[i]) {
ans += (a[i] / 2);
}
}
cout << ans / 2;
return 0;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
Everyone loves a freebie. Especially students.
It is well-known that if in the night before exam a student opens window, opens the student's record-book and shouts loudly three times "Fly, freebie, fly!" — then flown freebie helps him to pass the upcoming exam.
In the night before the exam on mathematical analysis n students living in dormitory shouted treasured words. The i-th student made a sacrament at the time ti, where ti is the number of seconds elapsed since the beginning of the night.
It is known that the freebie is a capricious and willful lady. That night the freebie was near dormitory only for T seconds. Therefore, if for two students their sacrament times differ for more than T, then the freebie didn't visit at least one of them.
Since all students are optimists, they really want to know what is the maximal number of students visited by the freebie can be.
Input
The first line of the input contains integer n (1 ≤ n ≤ 100), where n — the number of students shouted "Fly, freebie, fly!" The second line contains n positive integers ti (1 ≤ ti ≤ 1000).
The last line contains integer T (1 ≤ T ≤ 1000) — the time interval during which the freebie was near the dormitory.
Output
Print a single integer — the largest number of people who will pass exam tomorrow because of the freebie visit.
Examples
Input
6
4 1 7 8 3 8
1
Output
3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int ar[n];
for (int i = 0; i < n; i++) {
cin >> ar[i];
}
sort(ar, ar + n);
int t;
cin >> t;
int res = 0;
for (int i = 0; i < n - 1; i++) {
int count = 0;
for (int j = i + 1; j < n; j++) {
if (ar[j] - ar[i] <= t) {
count++;
res = max(res, count);
} else {
break;
}
}
}
cout << res + 1;
return 0;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
Vasya became interested in bioinformatics. He's going to write an article about similar cyclic DNA sequences, so he invented a new method for determining the similarity of cyclic sequences.
Let's assume that strings s and t have the same length n, then the function h(s, t) is defined as the number of positions in which the respective symbols of s and t are the same. Function h(s, t) can be used to define the function of Vasya distance ρ(s, t):
<image> where <image> is obtained from string s, by applying left circular shift i times. For example, ρ("AGC", "CGT") = h("AGC", "CGT") + h("AGC", "GTC") + h("AGC", "TCG") + h("GCA", "CGT") + h("GCA", "GTC") + h("GCA", "TCG") + h("CAG", "CGT") + h("CAG", "GTC") + h("CAG", "TCG") = 1 + 1 + 0 + 0 + 1 + 1 + 1 + 0 + 1 = 6
Vasya found a string s of length n on the Internet. Now he wants to count how many strings t there are such that the Vasya distance from the string s attains maximum possible value. Formally speaking, t must satisfy the equation: <image>.
Vasya could not try all possible strings to find an answer, so he needs your help. As the answer may be very large, count the number of such strings modulo 109 + 7.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 105).
The second line of the input contains a single string of length n, consisting of characters "ACGT".
Output
Print a single number — the answer modulo 109 + 7.
Examples
Input
1
C
Output
1
Input
2
AG
Output
4
Input
3
TTT
Output
1
Note
Please note that if for two distinct strings t1 and t2 values ρ(s, t1) и ρ(s, t2) are maximum among all possible t, then both strings must be taken into account in the answer even if one of them can be obtained by a circular shift of another one.
In the first sample, there is ρ("C", "C") = 1, for the remaining strings t of length 1 the value of ρ(s, t) is 0.
In the second sample, ρ("AG", "AG") = ρ("AG", "GA") = ρ("AG", "AA") = ρ("AG", "GG") = 4.
In the third sample, ρ("TTT", "TTT") = 27
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const double eps = 1e-8;
const int INF = 100000000;
const int MAX_N = 100005;
const int MAX_M = 100005;
int n;
char str[MAX_N];
int cnt[4];
int cal(int k, int n) {
long long res = 1, a = k;
while (n) {
if (n % 2) res = res * a % MOD;
n /= 2;
a = a * a % MOD;
}
return (int)res;
}
int main() {
cin >> n;
scanf("%s", str);
for (int i = 0; i < n; i++) {
if (str[i] == 'A')
cnt[0]++;
else if (str[i] == 'C')
cnt[1]++;
else if (str[i] == 'G')
cnt[2]++;
else
cnt[3]++;
}
sort(cnt, cnt + 4);
int k = 1;
for (int i = 2; i >= 0; i--) {
if (cnt[i] == cnt[3]) k++;
}
int ans = cal(k, n);
cout << ans << "\n";
return 0;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
On a two-dimensional plane, there are m lines drawn parallel to the x axis, and n lines drawn parallel to the y axis. Among the lines parallel to the x axis, the i-th from the bottom is represented by y = y_i. Similarly, among the lines parallel to the y axis, the i-th from the left is represented by x = x_i.
For every rectangle that is formed by these lines, find its area, and print the total area modulo 10^9+7.
That is, for every quadruple (i,j,k,l) satisfying 1\leq i < j\leq n and 1\leq k < l\leq m, find the area of the rectangle formed by the lines x=x_i, x=x_j, y=y_k and y=y_l, and print the sum of these areas modulo 10^9+7.
Constraints
* 2 \leq n,m \leq 10^5
* -10^9 \leq x_1 < ... < x_n \leq 10^9
* -10^9 \leq y_1 < ... < y_m \leq 10^9
* x_i and y_i are integers.
Input
Input is given from Standard Input in the following format:
n m
x_1 x_2 ... x_n
y_1 y_2 ... y_m
Output
Print the total area of the rectangles, modulo 10^9+7.
Examples
Input
3 3
1 3 4
1 3 6
Output
60
Input
6 5
-790013317 -192321079 95834122 418379342 586260100 802780784
-253230108 193944314 363756450 712662868 735867677
Output
835067060
### Response
```cpp
#include <iostream>
using namespace std;
typedef long long ll;
const int MOD = 1e9+7;
int main(){
int n, m; cin >> n >> m;
int x[n+1], y[m+1];
for(int i=1; i<=n; i++) cin >> x[i];
for(int i=1; i<=m; i++) cin >> y[i];
ll xsum=0, ysum=0;
for(int k=1; k<=n; k++){
xsum += 1LL*(k-1)*x[k]-1LL*(n-k)*x[k];
xsum %= MOD;
}
for(int k=1; k<=m; k++){
ysum += 1LL*(k-1)*y[k]-1LL*(m-k)*y[k];
ysum %= MOD;
}
cout << xsum*ysum%MOD << endl;
return 0;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
Little penguin Polo adores strings. But most of all he adores strings of length n.
One day he wanted to find a string that meets the following conditions:
1. The string consists of n lowercase English letters (that is, the string's length equals n), exactly k of these letters are distinct.
2. No two neighbouring letters of a string coincide; that is, if we represent a string as s = s1s2... sn, then the following inequality holds, si ≠ si + 1(1 ≤ i < n).
3. Among all strings that meet points 1 and 2, the required string is lexicographically smallest.
Help him find such string or state that such string doesn't exist.
String x = x1x2... xp is lexicographically less than string y = y1y2... yq, if either p < q and x1 = y1, x2 = y2, ... , xp = yp, or there is such number r (r < p, r < q), that x1 = y1, x2 = y2, ... , xr = yr and xr + 1 < yr + 1. The characters of the strings are compared by their ASCII codes.
Input
A single line contains two positive integers n and k (1 ≤ n ≤ 106, 1 ≤ k ≤ 26) — the string's length and the number of distinct letters.
Output
In a single line print the required string. If there isn't such string, print "-1" (without the quotes).
Examples
Input
7 4
Output
ababacd
Input
4 7
Output
-1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int n, k;
cin >> n >> k;
if (n < k or k > 26 or (n > 1 and k == 1))
cout << "-1" << endl;
else if (k == 1) {
bool a = true;
for (int i = 0; i < n; ++i) {
if (a)
cout << 'a';
else
cout << 'b';
a = !a;
}
cout << endl;
} else {
bool a = true;
int i = n;
while (i > k - 2) {
if (a) {
s += 'a';
a = !a;
} else {
s += 'b';
a = !a;
}
--i;
}
char c = 'c';
while (i > 0) {
s += c;
++c;
--i;
}
cout << s << endl;
}
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
People like to be fit. That's why many of them are ready to wake up at dawn, go to the stadium and run. In this problem your task is to help a company design a new stadium.
The city of N has a shabby old stadium. Many people like it and every morning thousands of people come out to this stadium to run. The stadium can be represented as a circle, its length is exactly l meters with a marked start line. However, there can't be simultaneous start in the morning, so exactly at 7, each runner goes to his favorite spot on the stadium and starts running from there. Note that not everybody runs in the same manner as everybody else. Some people run in the clockwise direction, some of them run in the counter-clockwise direction. It mostly depends on the runner's mood in the morning, so you can assume that each running direction is equiprobable for each runner in any fixed morning.
The stadium is tiny and is in need of major repair, for right now there only is one running track! You can't get too playful on a single track, that's why all runners keep the same running speed — exactly 1 meter per a time unit. Nevertheless, the runners that choose different directions bump into each other as they meet.
The company wants to design a new stadium, but they first need to know how bad the old one is. For that they need the expectation of the number of bumpings by t time units after the running has begun. Help the company count the required expectation. Note that each runner chooses a direction equiprobably, independently from the others and then all runners start running simultaneously at 7 a.m. Assume that each runner runs for t time units without stopping. Consider the runners to bump at a certain moment if at that moment they found themselves at the same point in the stadium. A pair of runners can bump more than once.
Input
The first line of the input contains three integers n, l, t (1 ≤ n ≤ 106, 1 ≤ l ≤ 109, 1 ≤ t ≤ 109). The next line contains n distinct integers a1, a2, ..., an (0 ≤ a1 < a2 < ... < an < l), here ai is the clockwise distance from the start line to the i-th runner's starting position.
Output
Print a single real number — the answer to the problem with absolute or relative error of at most 10 - 6.
Examples
Input
2 5 1
0 2
Output
0.2500000000
Input
3 7 3
0 1 6
Output
1.5000000000
Note
There are two runners in the first example. If the first runner run clockwise direction, then in 1 time unit he will be 1m away from the start line. If the second runner run counter-clockwise direction then in 1 time unit he will be also 1m away from the start line. And it is the only possible way to meet. We assume that each running direction is equiprobable, so the answer for the example is equal to 0.5·0.5 = 0.25.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, l, t, a[2000005];
int main() {
ios_base::sync_with_stdio(0);
cin.tie();
cin >> n >> l >> t;
for (int i = 0; i < n; ++i) {
cin >> a[i];
a[i + n] = a[i] + l;
}
int k = 2 * t / l, p = 2 * t % l;
double ans = 1.0 * k * n * (n - 1);
for (int i = 0, cnt = 0; i < n; i++) {
while (cnt < n + i && a[cnt] - a[i] <= p) cnt++;
ans += cnt - i - 1;
}
cout << setprecision(20) << ans / 4 << endl;
return 0;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
Takahashi will do a tap dance. The dance is described by a string S where each character is `L`, `R`, `U`, or `D`. These characters indicate the positions on which Takahashi should step. He will follow these instructions one by one in order, starting with the first character.
S is said to be easily playable if and only if it satisfies both of the following conditions:
* Every character in an odd position (1-st, 3-rd, 5-th, \ldots) is `R`, `U`, or `D`.
* Every character in an even position (2-nd, 4-th, 6-th, \ldots) is `L`, `U`, or `D`.
Your task is to print `Yes` if S is easily playable, and `No` otherwise.
Constraints
* S is a string of length between 1 and 100 (inclusive).
* Each character of S is `L`, `R`, `U`, or `D`.
Input
Input is given from Standard Input in the following format:
S
Output
Print `Yes` if S is easily playable, and `No` otherwise.
Examples
Input
RUDLUDR
Output
Yes
Input
DULL
Output
No
Input
UUUUUUUUUUUUUUU
Output
Yes
Input
ULURU
Output
No
Input
RDULULDURURLRDULRLR
Output
Yes
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(){
string s;
cin >> s;
int n = s.size();
bool ok = true;
for(int i=0; i<n; ++i){
if(i%2 == 0 && s[i] == 'L') ok = false;
else if(i%2 == 1 && s[i] == 'R') ok = false;
}
cout << (ok ? "Yes":"No") << endl;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
A permutation p of size n is an array such that every integer from 1 to n occurs exactly once in this array.
Let's call a permutation an almost identity permutation iff there exist at least n - k indices i (1 ≤ i ≤ n) such that pi = i.
Your task is to count the number of almost identity permutations for given numbers n and k.
Input
The first line contains two integers n and k (4 ≤ n ≤ 1000, 1 ≤ k ≤ 4).
Output
Print the number of almost identity permutations for given n and k.
Examples
Input
4 1
Output
1
Input
4 2
Output
7
Input
5 3
Output
31
Input
5 4
Output
76
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
long long ans = 1;
if (k >= 2) {
ans += n * (n - 1) / 2;
}
if (k >= 3) {
ans += n * (n - 1) * (n - 2) / 3;
}
if (k >= 4) {
ans += n * (n - 1) * (n - 2) * (n - 3) / 24 * 9;
}
cout << ans;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
As you could know there are no male planes nor female planes. However, each plane on Earth likes some other plane. There are n planes on Earth, numbered from 1 to n, and the plane with number i likes the plane with number fi, where 1 ≤ fi ≤ n and fi ≠ i.
We call a love triangle a situation in which plane A likes plane B, plane B likes plane C and plane C likes plane A. Find out if there is any love triangle on Earth.
Input
The first line contains a single integer n (2 ≤ n ≤ 5000) — the number of planes.
The second line contains n integers f1, f2, ..., fn (1 ≤ fi ≤ n, fi ≠ i), meaning that the i-th plane likes the fi-th.
Output
Output «YES» if there is a love triangle consisting of planes on Earth. Otherwise, output «NO».
You can output any letter in lower case or in upper case.
Examples
Input
5
2 4 5 1 3
Output
YES
Input
5
5 5 5 5 1
Output
NO
Note
In first example plane 2 likes plane 4, plane 4 likes plane 1, plane 1 likes plane 2 and that is a love triangle.
In second example there are no love triangles.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int a[5004];
int main() {
ios ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i <= n; i++) {
if (a[a[a[i]]] == i) {
cout << "YES" << endl;
return 0;
}
}
cout << "NO" << endl;
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
Given simple (without self-intersections) n-gon. It is not necessary convex. Also you are given m lines. For each line find the length of common part of the line and the n-gon.
The boundary of n-gon belongs to polygon. It is possible that n-gon contains 180-degree angles.
Input
The first line contains integers n and m (3 ≤ n ≤ 1000;1 ≤ m ≤ 100). The following n lines contain coordinates of polygon vertices (in clockwise or counterclockwise direction). All vertices are distinct.
The following m lines contain line descriptions. Each of them contains two distict points of a line by their coordinates.
All given in the input coordinates are real numbers, given with at most two digits after decimal point. They do not exceed 105 by absolute values.
Output
Print m lines, the i-th line should contain the length of common part of the given n-gon and the i-th line. The answer will be considered correct if the absolute or relative error doesn't exceed 10 - 6.
Examples
Input
4 3
0 0
1 0
1 1
0 1
0 0 1 1
0 0 0 1
0 0 1 -1
Output
1.41421356237309514547
1.00000000000000000000
0.00000000000000000000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using namespace rel_ops;
using float_type = long double;
float_type EPS = 1e-7;
constexpr float_type pi = 3.1415926535897932384626433832795L;
struct point;
struct vec;
struct line;
struct segment;
struct point {
float_type x, y;
point() {}
point(float_type xn, float_type yn) : x(xn), y(yn) {}
inline float_type dist_to(point dest) const {
return hypot(dest.x - x, dest.y - y);
}
inline float_type dist_to(line l) const;
inline bool operator==(const point &p) const { return dist_to(p) < EPS; }
inline bool operator<(const point &p) const {
return dist_to(p) >= EPS &&
(x <= (p.x - EPS) || (abs(x - p.x) < EPS && y < p.y));
}
inline bool inside_angle(const point &p1, const point &p2,
const point &s) const;
inline float_type dist_to(const segment &s) const;
inline bool on(const line &l) const;
inline bool on(const segment &s) const;
};
struct vec {
float_type x, y;
vec() {}
vec(float_type xn, float_type yn) : x(xn), y(yn) {}
vec(point a, point b) : x(b.x - a.x), y(b.y - a.y) {}
inline vec operator+(const vec &v) const { return vec(x + v.x, y + v.y); }
inline vec operator-(const vec &v) const { return vec(x - v.x, y - v.y); }
inline vec operator*(const float_type &c) const { return vec(x * c, y * c); }
inline float_type operator*(const vec &v) const { return x * v.x + y * v.y; }
inline float_type operator^(const vec &v) const { return x * v.y - y * v.x; }
inline float_type length() const { return hypot(x, y); }
};
inline point operator+(const point &p, const vec &v) {
return point(p.x + v.x, p.y + v.y);
}
inline point operator-(const point &p, const vec &v) {
return point(p.x - v.x, p.y - v.y);
}
struct line {
float_type a, b, c;
line() {}
line(float_type an, float_type bn, float_type cn) : a(an), b(bn), c(cn) {
normalize();
}
line(point p1, point p2)
: a(p1.y - p2.y), b(p2.x - p1.x), c(p1.x * p2.y - p2.x * p1.y) {
normalize();
}
line(point p, vec v) : line(p, p + v) {}
line(segment s);
inline void normalize() {
float_type sign = (abs(a) < EPS) ? b / abs(b) : a / abs(a);
float_type d = sqrt(a * a + b * b) * sign;
a /= d;
b /= d;
c /= d;
}
inline point intersect(line l) const {
return point((b * l.c - l.b * c) / (a * l.b - l.a * b),
(a * l.c - l.a * c) / (b * l.a - l.b * a));
}
inline bool parallel(line l) const {
return abs(a - l.a) < EPS && abs(b - l.b) < EPS && abs(c - l.c) >= EPS;
}
inline bool operator==(line l) const {
return abs(a - l.a) < EPS && abs(b - l.b) < EPS && abs(c - l.c) < EPS;
}
};
inline float_type point::dist_to(line l) const {
return abs(l.a * x + l.b * y + l.c);
}
inline bool point::inside_angle(const point &p1, const point &p2,
const point &s) const {
return (vec(s, p1) ^ vec(s, *this)) > -EPS &&
(vec(s, *this) ^ vec(s, p2)) > -EPS;
}
struct segment {
point a, b;
segment() {}
segment(point an, point bn) : a(an), b(bn) {}
segment(float_type x1, float_type y1, float_type x2, float_type y2)
: segment(point(x1, y1), point(x2, y2)) {}
inline float_type length() const { return a.dist_to(b); }
inline float_type dist_to(const segment &s) const;
inline segment shift(const vec &v) const { return segment(a + v, b + v); }
inline bool on(const line &l) const { return a.on(l) && b.on(l); }
};
line::line(segment s) : line(s.a, s.b) {}
inline bool point::on(const line &l) const {
return abs(l.a * x + l.b * y + l.c) < EPS;
}
inline float_type point::dist_to(const segment &s) const {
if (vec(s.a, s.b) * vec(s.a, *this) < EPS) {
return dist_to(s.a);
} else if (vec(s.b, s.a) * vec(s.b, *this) < EPS) {
return dist_to(s.b);
} else {
return dist_to(line(s));
}
}
inline bool point::on(const segment &s) const { return dist_to(s) < EPS; }
inline float_type segment::dist_to(const segment &s) const {
point i = line(*this).intersect(line(s));
if (i.on(s) && i.on(*this)) {
return 0.0;
} else {
return min(min((this->a).dist_to(s), (this->b).dist_to(s)),
min((s.a).dist_to(*this), (s.b).dist_to(*this)));
}
}
inline float_type angle(const vec &v, const vec &u) {
return atan2(v ^ u, v * u);
}
using polygon = vector<point>;
int main() {
ios::sync_with_stdio(false);
cout << fixed << setprecision(7);
int32_t n, m;
cin >> n >> m;
polygon poly1(n);
for (auto &p : poly1) {
cin >> p.x >> p.y;
}
polygon poly;
poly.reserve(n);
for (int32_t i = 0; i < n; ++i) {
int32_t pr = (i + n - 1) % n, ne = (i + 1) % n;
if (abs(vec(poly1[pr], poly1[i]) ^ vec(poly1[i], poly1[ne])) > EPS) {
poly.push_back(poly1[i]);
}
}
n = (int32_t)poly.size();
float_type agl = 0;
for (int32_t i = 0; i < n; ++i) {
int32_t pr = (i + n - 1) % n, ne = (i + 1) % n;
agl += angle(vec(poly[pr], poly[i]), vec(poly[i], poly[ne]));
}
if (agl < 0) {
reverse(poly.begin(), poly.end());
}
for (int32_t i = 0; i < m; ++i) {
point p1, p2;
cin >> p1.x >> p1.y >> p2.x >> p2.y;
line l = line(p1, p2);
vector<point> ps;
point pr = poly[n - 1], c = poly[0], ne = poly[1];
for (int32_t j = 0; j < n; ++j) {
if ((pr.on(l) && c.on(l)) || (c.on(l) && ne.on(l))) {
if ((vec(pr, c) ^ vec(c, ne)) > 0) {
ps.push_back(c);
}
} else if (c.on(l)) {
if (l.intersect(line(pr, ne)).on(segment(pr, ne))) {
ps.push_back(c);
}
} else {
point y = l.intersect(line(pr, c));
if (y.on(segment(pr, c)) && y != pr) {
ps.push_back(y);
}
}
pr = c;
c = ne;
ne = poly[(j + 2) % n];
}
sort(ps.begin(), ps.end());
float_type res = 0;
for (int32_t k = 0; k + 1 < (int32_t)ps.size(); k += 2) {
res += ps[k].dist_to(ps[k + 1]);
}
cout << res << endl;
}
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
Mad scientist Mike entertains himself by arranging rows of dominoes. He doesn't need dominoes, though: he uses rectangular magnets instead. Each magnet has two poles, positive (a "plus") and negative (a "minus"). If two magnets are put together at a close distance, then the like poles will repel each other and the opposite poles will attract each other.
Mike starts by laying one magnet horizontally on the table. During each following step Mike adds one more magnet horizontally to the right end of the row. Depending on how Mike puts the magnet on the table, it is either attracted to the previous one (forming a group of multiple magnets linked together) or repelled by it (then Mike lays this magnet at some distance to the right from the previous one). We assume that a sole magnet not linked to others forms a group of its own.
<image>
Mike arranged multiple magnets in a row. Determine the number of groups that the magnets formed.
Input
The first line of the input contains an integer n (1 ≤ n ≤ 100000) — the number of magnets. Then n lines follow. The i-th line (1 ≤ i ≤ n) contains either characters "01", if Mike put the i-th magnet in the "plus-minus" position, or characters "10", if Mike put the magnet in the "minus-plus" position.
Output
On the single line of the output print the number of groups of magnets.
Examples
Input
6
10
10
10
01
10
10
Output
3
Input
4
01
01
10
10
Output
2
Note
The first testcase corresponds to the figure. The testcase has three groups consisting of three, one and two magnets.
The second testcase has two groups, each consisting of two magnets.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string x, pre;
cin >> pre;
int gr = 1;
for (int i = 0; i < n - 1; i++) {
cin >> x;
if (pre[1] == x[0]) {
gr++;
}
pre = x;
}
cout << gr;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
Dante is engaged in a fight with "The Savior". Before he can fight it with his sword, he needs to break its shields. He has two guns, Ebony and Ivory, each of them is able to perform any non-negative number of shots.
For every bullet that hits the shield, Ebony deals a units of damage while Ivory deals b units of damage. In order to break the shield Dante has to deal exactly c units of damage. Find out if this is possible.
Input
The first line of the input contains three integers a, b, c (1 ≤ a, b ≤ 100, 1 ≤ c ≤ 10 000) — the number of units of damage dealt by Ebony gun and Ivory gun, and the total number of damage required to break the shield, respectively.
Output
Print "Yes" (without quotes) if Dante can deal exactly c damage to the shield and "No" (without quotes) otherwise.
Examples
Input
4 6 15
Output
No
Input
3 2 7
Output
Yes
Input
6 11 6
Output
Yes
Note
In the second sample, Dante can fire 1 bullet from Ebony and 2 from Ivory to deal exactly 1·3 + 2·2 = 7 damage. In the third sample, Dante can fire 1 bullet from ebony and no bullets from ivory to do 1·6 + 0·11 = 6 damage.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
for (int i = 0; i * a <= c; i++) {
for (int j = 0; j * b <= c; j++) {
if (c == a * i + b * j) {
cout << "YES";
return 0;
}
}
}
cout << "NO";
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
DO YOU EXPECT ME TO FIND THIS OUT?
WHAT BASE AND/XOR LANGUAGE INCLUDES string?
DON'T BYTE OF MORE THAN YOU CAN CHEW
YOU CAN ONLY DISTORT THE LARGEST OF MATHEMATICS SO FAR
SAYING "ABRACADABRA" WITHOUT A MAGIC AND WON'T DO YOU ANY GOOD
THE LAST STACK RUPTURES. ALL DIE. OH, THE EMBARRASSMENT!
I HAVE NO ARRAY AND I MUST SCREAM
ELEMENTS MAY NOT BE STORED IN WEST HYPERSPACE
Input
The first line of input data contains a single integer n (1 ≤ n ≤ 10).
The second line of input data contains n space-separated integers ai (1 ≤ ai ≤ 11).
Output
Output a single integer.
Example
Input
4
2 5 3 1
Output
4
### Response
```cpp
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
inline int read() {
char ch = getchar();
int f = 1;
while (!isdigit(ch)) {
if (ch == '-') f = -f;
ch = getchar();
}
int x = 0;
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return x * f;
}
int main() {
int n = read(), t, maxi = 0;
while (n--) maxi = max(maxi, t = read());
printf("%d\n", t ^ maxi);
return 0;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
Ryouko is an extremely forgetful girl, she could even forget something that has just happened. So in order to remember, she takes a notebook with her, called Ryouko's Memory Note. She writes what she sees and what she hears on the notebook, and the notebook became her memory.
Though Ryouko is forgetful, she is also born with superb analyzing abilities. However, analyzing depends greatly on gathered information, in other words, memory. So she has to shuffle through her notebook whenever she needs to analyze, which is tough work.
Ryouko's notebook consists of n pages, numbered from 1 to n. To make life (and this problem) easier, we consider that to turn from page x to page y, |x - y| pages should be turned. During analyzing, Ryouko needs m pieces of information, the i-th piece of information is on page ai. Information must be read from the notebook in order, so the total number of pages that Ryouko needs to turn is <image>.
Ryouko wants to decrease the number of pages that need to be turned. In order to achieve this, she can merge two pages of her notebook. If Ryouko merges page x to page y, she would copy all the information on page x to y (1 ≤ x, y ≤ n), and consequently, all elements in sequence a that was x would become y. Note that x can be equal to y, in which case no changes take place.
Please tell Ryouko the minimum number of pages that she needs to turn. Note she can apply the described operation at most once before the reading. Note that the answer can exceed 32-bit integers.
Input
The first line of input contains two integers n and m (1 ≤ n, m ≤ 105).
The next line contains m integers separated by spaces: a1, a2, ..., am (1 ≤ ai ≤ n).
Output
Print a single integer — the minimum number of pages Ryouko needs to turn.
Examples
Input
4 6
1 2 3 4 3 2
Output
3
Input
10 5
9 4 3 8 8
Output
6
Note
In the first sample, the optimal solution is to merge page 4 to 3, after merging sequence a becomes {1, 2, 3, 3, 3, 2}, so the number of pages Ryouko needs to turn is |1 - 2| + |2 - 3| + |3 - 3| + |3 - 3| + |3 - 2| = 3.
In the second sample, optimal solution is achieved by merging page 9 to 4.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[1000100];
bool vis[100100];
long long old[100100];
vector<int> e[100100];
long long ans, sum;
void build() {
for (int i = 1; i <= n; i++) e[i].clear();
memset(old, 0, sizeof(old));
for (int i = 1; i <= m; i++) {
if (a[i - 1] != a[i]) e[a[i]].push_back(a[i - 1]);
if (a[i + 1] != a[i]) e[a[i]].push_back(a[i + 1]);
old[a[i]] += abs(a[i] - a[i + 1]);
old[a[i]] += abs(a[i] - a[i - 1]);
}
}
void work() {
for (int i = 1; i <= n; i++) {
if (old[i] == 0) continue;
sort(e[i].begin(), e[i].end());
int mid = (e[i].size() + 1) / 2 - 1;
mid = e[i][mid];
vector<int>::iterator it;
long long tp = 0;
for (it = e[i].begin(); it != e[i].end(); it++) {
tp += abs(mid - *it);
}
if (tp < old[i]) ans = min(ans, sum - old[i] + tp);
}
}
int main() {
while (~scanf("%d%d", &n, &m)) {
for (int i = 1; i <= m; i++) scanf("%d", &a[i]);
sum = 0;
a[0] = a[1];
a[m + 1] = a[m];
for (int i = 1; i < m; i++) sum += abs(a[i + 1] - a[i]);
build();
ans = sum;
work();
cout << ans << endl;
}
return 0;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
There are N people living on a number line.
The i-th person lives at coordinate X_i.
You are going to hold a meeting that all N people have to attend.
The meeting can be held at any integer coordinate. If you choose to hold the meeting at coordinate P, the i-th person will spend (X_i - P)^2 points of stamina to attend the meeting.
Find the minimum total points of stamina the N people have to spend.
Constraints
* All values in input are integers.
* 1 \leq N \leq 100
* 1 \leq X_i \leq 100
Input
Input is given from Standard Input in the following format:
N
X_1 X_2 ... X_N
Output
Print the minimum total stamina the N people have to spend.
Examples
Input
2
1 4
Output
5
Input
7
14 14 2 13 56 2 37
Output
2354
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n,a,t;
vector<int>x(100);
cin >>n;
for(int i=0;i<n;i++){
cin >> x[i];
}
int mx =99999999;
for(int i=0;i<=100;i++){
t=0;
for(int j=0;j<n;j++){
a= abs(i-x[j]);
t+=pow((double)a,2);
}
mx=min(t,mx);
}
cout << mx<< endl;
return 0;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
Koa the Koala has a binary string s of length n. Koa can perform no more than n-1 (possibly zero) operations of the following form:
In one operation Koa selects positions i and i+1 for some i with 1 ≤ i < |s| and sets s_i to max(s_i, s_{i+1}). Then Koa deletes position i+1 from s (after the removal, the remaining parts are concatenated).
Note that after every operation the length of s decreases by 1.
How many different binary strings can Koa obtain by doing no more than n-1 (possibly zero) operations modulo 10^9+7 (1000000007)?
Input
The only line of input contains binary string s (1 ≤ |s| ≤ 10^6). For all i (1 ≤ i ≤ |s|) s_i = 0 or s_i = 1.
Output
On a single line print the answer to the problem modulo 10^9+7 (1000000007).
Examples
Input
000
Output
3
Input
0101
Output
6
Input
0001111
Output
16
Input
00101100011100
Output
477
Note
In the first sample Koa can obtain binary strings: 0, 00 and 000.
In the second sample Koa can obtain binary strings: 1, 01, 11, 011, 101 and 0101. For example:
* to obtain 01 from 0101 Koa can operate as follows: 0101 → 0(10)1 → 011 → 0(11) → 01.
* to obtain 11 from 0101 Koa can operate as follows: 0101 → (01)01 → 101 → 1(01) → 11.
Parentheses denote the two positions Koa selected in each operation.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using Vi = vector<int>;
using Pii = pair<int, int>;
using Pll = pair<ll, ll>;
using Ppi = pair<Pii, int>;
const long long mod = 1000000007;
const int inf = 1e9 + 7;
struct Tree {
int base = 1;
vector<int> mini;
Tree(int n) {
while (base < n + 2) base *= 2;
mini.resize(2 * base, inf);
}
void insert(int a, int c) {
a += base;
while (a >= 1) {
mini[a] = min(mini[a], c);
a /= 2;
}
}
int query(int a, int b) {
a += base;
b += base;
int res = min(mini[a], mini[b]);
if (a == b) return res;
while (a / 2 != b / 2) {
if (a % 2 == 0) res = min(res, mini[a + 1]);
if (b % 2 == 1) res = min(res, mini[b - 1]);
a /= 2;
b /= 2;
}
return res;
}
};
string s;
int n;
const int maxS = 1000011;
long long dp[maxS];
long long dp2[maxS];
void solve() {
cin >> s;
n = int((s).size());
vector<Pii> V;
Tree tree(1e6 + 10);
for (int b = 0; b < n;) {
int e = b;
while (e < n && s[b] == s[e]) {
e++;
}
V.push_back({s[b] - '0', e - b});
b = e;
}
int k = int((V).size());
k--;
int add = 0;
for (int i = k; i >= 0; i--) {
if (V[i].first == 1) {
dp[i] = V[i].second * (dp[i + 1] + 1 + add) + dp[i + 2];
dp[i] %= mod;
}
if (V[i].first == 0) {
if (i == k) add = V[i].second;
dp[i] = V[i].second * dp[i + 1];
dp[i] %= mod;
int l1 = V[i].second;
tree.insert(l1, i);
int prev = tree.query(l1 + 1, 1e6 + 1);
if (prev == inf) continue;
int l2 = V[prev].second;
dp2[i] = (l2 - l1) * dp[prev + 1] + dp2[prev];
dp2[i] %= mod;
dp[i] += dp2[i];
dp[i] %= mod;
}
}
if (k == 0) {
cout << dp[0] + add << '\n';
return;
}
if (V[0].first == 1) {
cout << dp[0] << '\n';
return;
}
ll res = (V[0].second + 1) * dp[1];
res %= mod;
cout << res << '\n';
}
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(18);
int z = 1;
for (int i = 0; i < z; i++) {
solve();
}
return 0;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
Some of you know an old story of Voronoi Island. There were N liege lords and they are always involved in territorial disputes. The residents of the island were despaired of the disputes.
One day, a clever lord proposed to stop the disputes and divide the island fairly. His idea was to divide the island such that any piece of area belongs to the load of the nearest castle. The method is called Voronoi Division today.
Actually, there are many aspects of whether the method is fair. According to one historian, the clever lord suggested the method because he could gain broader area than other lords.
Your task is to write a program to calculate the size of the area each lord can gain. You may assume that Voronoi Island has a convex shape.
Input
The input consists of multiple datasets. Each dataset has the following format:
N M
Ix1 Iy1
Ix2 Iy2
...
IxN IyN
Cx1 Cy1
Cx2 Cy2
...
CxM CyM
N is the number of the vertices of Voronoi Island; M is the number of the liege lords; (Ixi, Iyi) denotes the coordinate of the i-th vertex; (Cxi, Cyi ) denotes the coordinate of the castle of the i-the lord.
The input meets the following constraints: 3 ≤ N ≤ 10, 2 ≤ M ≤ 10, -100 ≤ Ixi, Iyi, Cxi, Cyi ≤ 100. The vertices are given counterclockwise. All the coordinates are integers.
The last dataset is followed by a line containing two zeros. This line is not a part of any dataset and should not be processed.
Output
For each dataset, print the area gained by each liege lord with an absolute error of at most 10-4 . You may output any number of digits after the decimal point. The order of the output areas must match that of the lords in the input.
Example
Input
3 3
0 0
8 0
0 8
2 2
4 2
2 4
0 0
Output
9.0
11.5
11.5
### Response
```cpp
#include<cstdio>
#include<vector>
#include<cmath>
#include<algorithm>
#include<string>
#include<cstring>
using namespace std;
#define rep(i,n) for(int i=0;i<((int)(n));i++)
#define reg(i,a,b) for(int i=((int)(a));i<=((int)(b));i++)
#define irep(i,n) for(int i=((int)(n))-1;i>=0;i--)
#define ireg(i,a,b) for(int i=((int)(b));i>=((int)(a));i--)
typedef long long int lli;
typedef pair<int,int> mp;
#define fir first
#define sec second
typedef double D;
const D pi=3.14159265358979;
struct P{
D x,y,n,n2;
D norm,norm2;
P(){}
P(D ix,D iy){
x=ix; y=iy;
n2=x*x+y*y;
n=sqrt(n2);
}
P to(P a){
return (a-(*this));
}
P operator+(P a)const{
return P(x+a.x,y+a.y);
}
P operator-(P a)const{
return P(x-a.x,y-a.y);
}
P scalar(D a){
return P(x*a,y*a);
}
D dot(P a){
return x*a.x + y*a.y;
}
D cross(P a){
return x*a.y - y*a.x;
}
D theta(P a){
D s = (cross(a)/(n*a.n))>0.0?1:-1;
return acos(max(-1.0,min(1.0,dot(a)/(n*a.n))))*s;
}
static P polar(D r,D t){
return P(r*cos(t),r*sin(t));
}
P turn(D t){
return P(x*cos(t)-y*sin(t),x*sin(t)+y*cos(t));
}
P tolen(D a){
return this->scalar(a/n);
}
bool operator<(P a) const{
if(y!=a.y)return (y<a.y);
return (x<a.x);
}
bool operator>(P a)const{ return (a<(*this)); }
};
struct L{
P p,q,v;
L(){}
L(P ip,P iq){
p=ip; q=iq;
v=p.to(q);
}
bool iscross(L a){
D da,db;
da=v.cross(p.to(a.p));
db=v.cross(p.to(a.q));
if(da*db>=0)return false;
da=a.v.cross(a.p.to(p));
db=a.v.cross(a.p.to(q));
return (da*db<0);
}
D dist(P a){
if(p.to(a).dot(p.to(q))<0)return p.to(a).n;
if(q.to(a).dot(q.to(p))<0)return q.to(a).n;
return abs(v.cross(p.to(a))/v.n);
}
D dist(L a){
if(iscross(a))return 0;
return min(min(dist(a.p),dist(a.q)) , min(a.dist(this->p),a.dist(this->q)));
}
P crosspos(L a){
return (p+v.scalar(a.v.cross(a.p-p)/a.v.cross(v)));
}
L bisection(){//垂直二等分線
//半時計回りに90度回った向きの。
P fr=(p+q).scalar(0.5);
P to=fr+P(-v.y,v.x);
return L(fr,to);
}
};
struct Pol{
vector<P> ps;
Pol(){}
D area(){
D res=0;
rep(i,ps.size()){
P no=ps[i],to=ps[(i+1)%ps.size()];
res+=(no.x+to.x)*(no.y-to.y);
}
if(res<0)reverse(ps.begin(),ps.end());
return abs(res)/2;
}
Pol(P a,P b){
ps.push_back(a);
ps.push_back(P(a.x,b.y));
ps.push_back(b);
ps.push_back(P(b.x,a.y));
}
L gete(int a){
a%=ps.size();
return L(ps[a],ps[(a+1)%ps.size()]);
}
int isin(P a){//内側なら2,乗ってるなら1,外なら0
D as=0;
rep(i,ps.size()){
L ne=gete(i);
if(ne.dist(a)<=0)return 1;
P v1=a.to(ne.p);
P v2=a.to(ne.q);
as+=v1.theta(v2);
}
if(abs(as)<1e-6)return 0;
return 2;
}
Pol cut(L a){//進行方向右手を残す
Pol res;
rep(i,ps.size()){
L ne=gete(i);
D d1=a.v.cross(a.p.to(ne.p));
D d2=a.v.cross(a.p.to(ne.q));
if(d1<1e-6)res.ps.push_back(ne.p); //こっちは正のeps
if(d1*d2<-1e-6)res.ps.push_back(a.crosspos(ne)); //こっちは負のeps
}
return res;
}
vector<Pol> voronoi(vector<P> ps){
//validate AOJ 2160
vector<Pol> res;
rep(i,ps.size()){
Pol np(*this);
rep(j,ps.size()){
if(i==j)continue;
L nl = L(ps[j],ps[i]).bisection();
np = np.cut(nl);
}
res.push_back(np);
}
return res;
}
};
int main(){
for(;;){
int n,m;
scanf("%d%d",&n,&m);
if(n==0)break;
Pol po;
rep(i,n){
double x,y;
scanf("%lf%lf",&x,&y);
po.ps.push_back(P(x,y));
}
vector<P> tps;
rep(i,m){
double x,y;
scanf("%lf%lf",&x,&y);
tps.push_back(P(x,y));
}
vector<Pol> anss = po.voronoi(tps);
rep(i,anss.size()){
printf("%lf\n",anss[i].area());
}
}
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
The Little Elephant very much loves sums on intervals.
This time he has a pair of integers l and r (l ≤ r). The Little Elephant has to find the number of such integers x (l ≤ x ≤ r), that the first digit of integer x equals the last one (in decimal notation). For example, such numbers as 101, 477474 or 9 will be included in the answer and 47, 253 or 1020 will not.
Help him and count the number of described numbers x for a given pair l and r.
Input
The single line contains a pair of integers l and r (1 ≤ l ≤ r ≤ 1018) — the boundaries of the interval.
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use cin, cout streams or the %I64d specifier.
Output
On a single line print a single integer — the answer to the problem.
Examples
Input
2 47
Output
12
Input
47 1024
Output
98
Note
In the first sample the answer includes integers 2, 3, 4, 5, 6, 7, 8, 9, 11, 22, 33, 44.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int coun(long long x) {
int count = 0;
while (x) {
x /= 10;
count++;
}
return count;
}
int main() {
long long int l, r;
cin >> l >> r;
long long m1 = 1;
long long m2 = 1;
int x = coun(l);
for (int i = 1; i < x; i++) m1 *= 10;
int y = coun(r);
for (int i = 1; i < y; i++) m2 *= 10;
long long count = 0;
if (x >= 2)
for (int i = 1; i < l / m1; i++) count += (x < 2) ? (1) : (m1 / 10);
long long count2 = (x < 2) ? (l - 1) : (l % m1) / 10;
if (x >= 2 && l % 10 > (l / m1)) count2++;
count += count2;
count = ((x < 2) ? (9) : (m1 / 10 * 9)) - count;
x++;
m1 *= 10;
while (x <= y) {
count += (m1 / 10 * 9);
m1 *= 10;
x++;
}
long long int count3 = 0;
if (y >= 2)
for (int i = r / m2 + 1; i <= 9; i++) count3 += m2 / 10;
count3 += (y < 2) ? (9 - r) : ((r / m2 + 1) * m2 / 10 - (r / 10));
if (y >= 2 && r % 10 >= (r / m2)) count3--;
count -= count3;
cout << count << endl;
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
Polycarpus analyzes a string called abracadabra. This string is constructed using the following algorithm:
* On the first step the string consists of a single character "a".
* On the k-th step Polycarpus concatenates two copies of the string obtained on the (k - 1)-th step, while inserting the k-th character of the alphabet between them. Polycarpus uses the alphabet that consists of lowercase Latin letters and digits (a total of 36 characters). The alphabet characters are numbered like this: the 1-st character is "a", the 2-nd — "b", ..., the 26-th — "z", the 27-th — "0", the 28-th — "1", ..., the 36-th — "9".
Let's have a closer look at the algorithm. On the second step Polycarpus will concatenate two strings "a" and insert the character "b" between them, resulting in "aba" string. The third step will transform it into "abacaba", and the fourth one - into "abacabadabacaba". Thus, the string constructed on the k-th step will consist of 2k - 1 characters.
Polycarpus wrote down the string he got after 30 steps of the given algorithm and chose two non-empty substrings of it. Your task is to find the length of the longest common substring of the two substrings selected by Polycarpus.
A substring s[i... j] (1 ≤ i ≤ j ≤ |s|) of string s = s1s2... s|s| is a string sisi + 1... sj. For example, substring s[2...4] of string s = "abacaba" equals "bac". The string is its own substring.
The longest common substring of two strings s and t is the longest string that is a substring of both s and t. For example, the longest common substring of "contest" and "systemtesting" is string "test". There can be several common substrings of maximum length.
Input
The input consists of a single line containing four integers l1, r1, l2, r2 (1 ≤ li ≤ ri ≤ 109, i = 1, 2). The numbers are separated by single spaces. li and ri give the indices of the first and the last characters of the i-th chosen substring, correspondingly (i = 1, 2). The characters of string abracadabra are numbered starting from 1.
Output
Print a single number — the length of the longest common substring of the given strings. If there are no common substrings, print 0.
Examples
Input
3 6 1 4
Output
2
Input
1 1 4 4
Output
0
Note
In the first sample the first substring is "acab", the second one is "abac". These two substrings have two longest common substrings "ac" and "ab", but we are only interested in their length — 2.
In the second sample the first substring is "a", the second one is "c". These two substrings don't have any common characters, so the length of their longest common substring is 0.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int a, b, c, d;
int f(int a, int b, int c, int d, int n) {
if (a > b || c > d) return 0;
if (a == c) return min(b, d) - a + 1;
if (a > c) swap(a, c), swap(b, d);
if (b >= d) return d - c + 1;
int x = 1 << n;
if (b < x && d < x) return f(a, b, c, d, n - 1);
if (a > x && c > x) return f(a - x, b - x, c - x, d - x, n);
if (c > x) return f(a, b, c - x, d - x, n);
return max(b - c + 1, max(f(a, b, c, x - 1, n), f(a, b, x + 1, d, n)));
}
int main() {
cin >> a >> b >> c >> d;
cout << f(a, b, c, d, 30);
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
All techniques in the ninja world consist of hand seals. At the moment Naruto is learning a new technique, which consists of n⋅ m different seals, denoted by distinct numbers. All of them were written in an n× m table.
The table is lost now. Naruto managed to remember elements of each row from left to right, and elements of each column from top to bottom, but he doesn't remember the order of rows and columns. Please restore the table consistent with this data so that Naruto will be able to learn the new technique.
Input
The first line of the input contains the only integer t (1≤ t≤ 100 000) denoting the number of test cases. Their descriptions follow.
The first line of each test case description consists of two space-separated integers n and m (1 ≤ n, m ≤ 500) standing for the number of rows and columns in the table, respectively. All hand seals are encoded by the positive integers from 1 to n⋅ m.
The following n lines contain m space separated integers each, denoting elements of an arbitrary row in the table left to right.
The following m lines contain n space separated integers each, denoting elements of an arbitrary column in the table top to bottom.
Sum of nm over all test cases does not exceed 250 000. It is guaranteed that each row occurs in the input exactly once, as well as each column. It is also guaranteed that each number from 1 to nm occurs exactly once in all rows, as well as in all columns. Finally, it is guaranteed that a table consistent with the input exists.
Output
For each test case, output n lines with m space-separated integers each, denoting the restored table. One can show that the answer is always unique.
Example
Input
2
2 3
6 5 4
1 2 3
1 6
2 5
3 4
3 1
2
3
1
3 1 2
Output
1 2 3
6 5 4
3
1
2
Note
Consider the first test case. The matrix is 2 × 3. You are given the rows and columns in arbitrary order.
One of the rows is [6, 5, 4]. One of the rows is [1, 2, 3].
One of the columns is [1, 6]. One of the columns is [2, 5]. One of the columns is [3, 4].
You are to reconstruct the matrix. The answer is given in the output.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int T;
cin >> T;
int n, m;
for (int l = 0; l != T; ++l) {
cin >> n >> m;
vector<vector<int>> line(n);
vector<vector<int>> pillar(m);
for (int i = 0; i != n; ++i) {
for (int j = 0; j != m; ++j) {
(line[i]).push_back(0);
cin >> line[i][j];
}
}
for (int i = 0; i != m; ++i) {
for (int j = 0; j != n; ++j) {
(pillar[i]).push_back(0);
cin >> pillar[i][j];
}
}
for (int i = 0; i != m; ++i) {
for (int j = 0; j != m; ++j) {
for (int k = 0; k != n; ++k) {
if (line[0][i] == pillar[j][k]) {
swap(pillar[j], pillar[i]);
break;
}
}
}
}
for (int j = 0; j != n; ++j) {
for (int i = 0; i != m; ++i) {
cout << pillar[i][j] << " ";
}
cout << endl;
}
}
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
A group of n schoolboys decided to ride bikes. As nobody of them has a bike, the boys need to rent them.
The renting site offered them m bikes. The renting price is different for different bikes, renting the j-th bike costs pj rubles.
In total, the boys' shared budget is a rubles. Besides, each of them has his own personal money, the i-th boy has bi personal rubles. The shared budget can be spent on any schoolchildren arbitrarily, but each boy's personal money can be spent on renting only this boy's bike.
Each boy can rent at most one bike, one cannot give his bike to somebody else.
What maximum number of schoolboys will be able to ride bikes? What minimum sum of personal money will they have to spend in total to let as many schoolchildren ride bikes as possible?
Input
The first line of the input contains three integers n, m and a (1 ≤ n, m ≤ 105; 0 ≤ a ≤ 109). The second line contains the sequence of integers b1, b2, ..., bn (1 ≤ bi ≤ 104), where bi is the amount of the i-th boy's personal money. The third line contains the sequence of integers p1, p2, ..., pm (1 ≤ pj ≤ 109), where pj is the price for renting the j-th bike.
Output
Print two integers r and s, where r is the maximum number of schoolboys that can rent a bike and s is the minimum total personal money needed to rent r bikes. If the schoolchildren cannot rent any bikes, then r = s = 0.
Examples
Input
2 2 10
5 5
7 6
Output
2 3
Input
4 5 2
8 1 1 2
6 3 7 5 2
Output
3 8
Note
In the first sample both schoolchildren can rent a bike. For instance, they can split the shared budget in half (5 rubles each). In this case one of them will have to pay 1 ruble from the personal money and the other one will have to pay 2 rubles from the personal money. In total, they spend 3 rubles of their personal money. This way of distribution of money minimizes the amount of spent personal money.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int p[100010], a[100010];
int sum;
long long ret, sum1[100010], sum2[100010];
bool cmp(int a, int b) { return a > b; }
bool find(int mid) {
if (sum2[mid] > sum1[mid] + sum) return false;
long long ret1, mm = 0, oo;
ret1 = sum2[mid] - sum;
if (ret1 <= 0) {
ret = 0;
return true;
}
ret = ret1;
oo = sum;
int kk;
for (int i = 1; i <= mid; i++) {
if (a[mid - i + 1] <= p[i])
mm += a[mid - i + 1];
else
mm += p[i];
if (mm >= ret1) return true;
kk = p[i] - a[mid - i + 1];
if (kk > oo) return false;
if (kk > 0) oo -= kk;
}
return false;
}
int main() {
int n, m, k, i;
int L, R, mid, j;
while (scanf("%d%d%d", &n, &m, &sum) != EOF) {
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i <= m; i++) scanf("%d", &p[i]);
sum1[0] = sum2[0] = 0;
sort(p + 1, p + m + 1);
sort(a + 1, a + 1 + n, cmp);
for (i = 1; i <= n; i++) sum1[i] = sum1[i - 1] + a[i];
for (i = 1; i <= m; i++) sum2[i] = sum2[i - 1] + p[i];
L = 0;
R = min(n, m);
ret = 0;
while (L <= R) {
mid = (L + R) >> 1;
if (find(mid))
L = mid + 1;
else
R = mid - 1;
}
mid = min(L, R);
find(mid);
printf("%d %I64d\n", mid, ret);
}
return 0;
}
``` |
Subsets and Splits