text
stringlengths 424
69.5k
|
|---|
### Prompt
Create a solution in Cpp for the following problem:
Pavel plays a famous computer game. A player is responsible for a whole country and he can travel there freely, complete quests and earn experience.
This country has n cities connected by m bidirectional roads of different lengths so that it is possible to get from any city to any other one. There are portals in k of these cities. At the beginning of the game all portals are closed. When a player visits a portal city, the portal opens. Strange as it is, one can teleport from an open portal to an open one. The teleportation takes no time and that enables the player to travel quickly between rather remote regions of the country.
At the beginning of the game Pavel is in city number 1. He wants to open all portals as quickly as possible. How much time will he need for that?
Input
The first line contains two space-separated integers n and m (1 ≤ n ≤ 105, 0 ≤ m ≤ 105) that show how many cities and roads are in the game.
Each of the next m lines contains the description of a road as three space-separated integers xi, yi, wi (1 ≤ xi, yi ≤ n, xi ≠ yi, 1 ≤ wi ≤ 109) — the numbers of the cities connected by the i-th road and the time needed to go from one city to the other one by this road. Any two cities are connected by no more than one road. It is guaranteed that we can get from any city to any other one, moving along the roads of the country.
The next line contains integer k (1 ≤ k ≤ n) — the number of portals.
The next line contains k space-separated integers p1, p2, ..., pk — numbers of the cities with installed portals. Each city has no more than one portal.
Output
Print a single number — the minimum time a player needs to open all portals.
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
3 3
1 2 1
1 3 1
2 3 1
3
1 2 3
Output
2
Input
4 3
1 2 1
2 3 5
2 4 10
3
2 3 4
Output
16
Input
4 3
1 2 1000000000
2 3 1000000000
3 4 1000000000
4
1 2 3 4
Output
3000000000
Note
In the second sample the player has to come to city 2, open a portal there, then go to city 3, open a portal there, teleport back to city 2 and finally finish the journey in city 4.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int MAX = 1e9 + 5;
int n, m, x, y, z, k, p[N], wh[N], node, root[N];
long long val, ans, sp[N], cost;
vector<pair<int, int> > v[N];
vector<pair<long long, pair<int, int> > > edges;
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
q;
int findset(int node) {
if (root[node] == node) return node;
return root[node] = findset(root[node]);
}
void dijkstra() {
while (!q.empty()) {
node = q.top().second;
val = q.top().first;
q.pop();
if (sp[node] < val) continue;
for (__typeof(v[node].begin()) it = v[node].begin(); it != v[node].end();
it++)
if (sp[it->first] > sp[node] + it->second) {
sp[it->first] = sp[node] + it->second;
wh[it->first] = wh[node];
q.push(make_pair(sp[it->first], it->first));
}
}
}
long long kruskal() {
for (int i = 1; i <= n; i++)
for (__typeof(v[i].begin()) it = v[i].begin(); it != v[i].end(); it++)
if (it->first > i)
edges.push_back(make_pair(sp[i] + it->second + sp[it->first],
make_pair(wh[i], wh[it->first])));
sort(edges.begin(), edges.end());
for (__typeof(edges.begin()) it = edges.begin(); it != edges.end(); it++) {
long long cost = it->first;
long long x = it->second.first;
long long y = it->second.second;
if (findset(x) == findset(y)) continue;
root[findset(x)] = findset(y);
ans += cost;
}
return ans + sp[1];
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d %d %d", &x, &y, &z);
v[x].push_back(make_pair(y, z));
v[y].push_back(make_pair(x, z));
}
scanf("%d", &k);
for (int i = 1; i <= k; i++) {
scanf("%d", &p[i]);
q.push(make_pair(0, p[i]));
wh[p[i]] = p[i];
}
for (int i = 1; i <= n; i++) {
root[i] = i;
sp[i] = 1000000000000000000LL * (wh[i] == 0);
}
dijkstra();
cout << kruskal();
return 0;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
We have a magic tree: a rooted tree on n vertices. The vertices are numbered 1 through n. Vertex 1 is the root.
The magic tree gives us magic fruit. The fruit only grows in vertices of the tree other than the root. Each vertex contains at most one piece of fruit.
It is now day 0 and no fruit is ripe yet. Each fruit will only be ripe for a single day. For each fruit, we are given the vertex v_j where it grows, the day d_j on which it will be ripe, and the amount w_j of magic juice we can extract from it if we harvest it when it is ripe.
The fruits have to be harvested by cutting some branches of the tree. On each day, you may cut as many branches of the tree as you like. The parts of the tree you cut off will fall to the ground and you can collect all the ripe fruits they contain. All fruits that fall to the ground when they are not ripe are discarded and no magic juice is collected from them.
Formally, on each day, you may erase some edges of the tree. Whenever you do so, the tree will split into multiple connected components. You then erase all components that do not contain the root and you harvest all ripe fruits those components contained.
Given is a description of the tree together with the locations, ripening days and juiciness of all m fruits. Calculate the maximum total amount of magic juice we can harvest from the tree.
Input
The first line contains three space-separated integers n (2 ≤ n ≤ 100,000), m (1 ≤ m ≤ n-1) and k (1 ≤ k ≤ 100,000) – the number of vertices, the number of fruits, and the maximum day on which a fruit may become ripe.
The following n-1 lines contain the integers p_2, ..., p_n, one per line. For each i (from 2 to n, inclusive), vertex p_i (1 ≤ p_i ≤ i-1) is the parent of vertex i.
Each of the last m lines describes one fruit. The j-th of these lines has the form "v_j\ d_j\ w_j" (2 ≤ v_j ≤ n, 1 ≤ d_j ≤ k, 1 ≤ w_j ≤ 10^9).
It is guaranteed that no vertex contains more than one fruit (i.e., the values v_j are distinct).
Output
Output a single line with a single integer, the maximum amount of magic juice we can harvest from the tree.
Scoring
Subtask 1 (6 points): n, k ≤ 20, and w_j = 1 for all j
Subtask 2 (3 points): fruits only grow in the leaves of the tree
Subtask 3 (11 points): p_i = i-1 for each i, and w_j = 1 for all j
Subtask 4 (12 points): k ≤ 2
Subtask 5 (16 points): k ≤ 20, and w_j = 1 for all j
Subtask 6 (13 points): m ≤ 1,000
Subtask 7 (22 points): w_j = 1 for all j
Subtask 8 (17 points): no additional constraints
Example
Input
6 4 10
1
2
1
4
4
3 4 5
4 7 2
5 4 1
6 9 3
Output
9
Note
In the example input, one optimal solution looks as follows:
* On day 4, cut the edge between vertices 4 and 5 and harvest a ripe fruit with 1 unit of magic juice. On the same day, cut the edge between vertices 1 and 2 and harvest 5 units of magic juice from the ripe fruit in vertex 3.
* On day 7, do nothing. (We could harvest the fruit in vertex 4 that just became ripe, but doing so is not optimal.)
* On day 9, cut the edge between vertices 1 and 4. Discard the fruit in vertex 4 that is no longer ripe, and harvest 3 units of magic juice from the ripe fruit in vertex 6. (Alternately, we could achieve the same effect by cutting the edge between vertices 4 and 6.)
### Response
```cpp
#include <bits/stdc++.h>
const int MAXN = 1e5 + 10;
using namespace std;
int N, M, K;
int dia[MAXN], sub[MAXN];
vector<int> adj[MAXN];
long long W[MAXN];
map<int, long long> *mp[MAXN];
void dfs(int x) {
sub[x] = 1;
int bc = -1;
for (auto e : adj[x]) {
if (e < x) continue;
dfs(e);
sub[x] += sub[e];
if (bc == -1 || sub[e] > sub[bc]) bc = e;
}
if (bc == -1) {
mp[x] = new map<int, long long>;
(*mp[x]).insert(make_pair(dia[x], W[x]));
return;
} else
mp[x] = mp[bc];
for (auto e : adj[x]) {
if (e < x || e == bc) continue;
for (auto it = (*mp[e]).begin(); it != (*mp[e]).end(); it++)
(*mp[x])[it->first] += it->second;
}
if (dia[x] == 0) return;
(*mp[x])[dia[x]] += W[x];
auto it = (*mp[x]).find(dia[x]);
it++;
vector<int> toDelete;
long long cnt = 0LL;
while (it != (*mp[x]).end() && cnt + it->second <= W[x]) {
toDelete.push_back(it->first);
cnt += it->second;
it++;
}
if (it != (*mp[x]).end()) (*mp[x])[it->first] += cnt - W[x];
for (auto e : toDelete) (*mp[x]).erase((*mp[x]).find(e));
}
int main() {
scanf("%d%d%d", &N, &M, &K);
for (int i = 2, x; i <= N; i++) {
scanf("%d", &x);
adj[x].push_back(i);
}
for (int i = 1, x, y; i <= M; i++) {
long long z;
scanf("%d%d%lld", &x, &y, &z);
dia[x] = y;
W[x] = z;
}
dfs(1);
long long cnt = 0LL;
for (auto e : (*mp[1])) cnt += e.second;
printf("%lld\n", cnt);
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
Hongcow is learning to spell! One day, his teacher gives him a word that he needs to learn to spell. Being a dutiful student, he immediately learns how to spell the word.
Hongcow has decided to try to make new words from this one. He starts by taking the word he just learned how to spell, and moves the last character of the word to the beginning of the word. He calls this a cyclic shift. He can apply cyclic shift many times. For example, consecutively applying cyclic shift operation to the word "abracadabra" Hongcow will get words "aabracadabr", "raabracadab" and so on.
Hongcow is now wondering how many distinct words he can generate by doing the cyclic shift arbitrarily many times. The initial string is also counted.
Input
The first line of input will be a single string s (1 ≤ |s| ≤ 50), the word Hongcow initially learns how to spell. The string s consists only of lowercase English letters ('a'–'z').
Output
Output a single integer equal to the number of distinct strings that Hongcow can obtain by applying the cyclic shift arbitrarily many times to the given string.
Examples
Input
abcd
Output
4
Input
bbb
Output
1
Input
yzyz
Output
2
Note
For the first sample, the strings Hongcow can generate are "abcd", "dabc", "cdab", and "bcda".
For the second sample, no matter how many times Hongcow does the cyclic shift, Hongcow can only generate "bbb".
For the third sample, the two strings Hongcow can generate are "yzyz" and "zyzy".
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T power(T base, int p) {
T f = 1;
for (int i = 1; i <= p; i++) f *= base;
return f;
}
template <typename T>
string NumberToString(T Number) {
ostringstream ss;
ss << Number;
return ss.str();
}
int setbit(int N, int pos) { return N = N | (1 << pos); }
int resetbit(int N, int pos) { return N = N & ~(1 << pos); }
bool checkbit(int N, int pos) { return (bool)(N & (1 << pos)); }
int noofsetbits(int N) { return __builtin_popcount(N); }
long long int bigMod(long long int N, long long int M, long long int MOD) {
if (M == 0) return 1;
if ((M / 2) * 2 == M) {
long long int ret = bigMod(N, M / 2, MOD) % MOD;
return (ret * ret) % MOD;
} else
return ((N % MOD) * bigMod(N, M - 1, MOD) % MOD) % MOD;
}
long long int modInverseBigMod(long long int a, long long int m) {
return bigMod(a, m - 2, m);
}
pair<int, int> extendedEuclid(long long int a, long long int b) {
if (b == 0) return pair<int, int>(1, 0);
pair<int, int> d = extendedEuclid(b, a % b);
return pair<int, int>(d.second, d.first - d.second * (a / b));
}
long long int modularInverse(long long int a, long long int m) {
pair<int, int> ret = extendedEuclid(a, m);
return ((ret.first % m) + m) % m;
}
map<string, bool> mp;
string shift(string s) {
char lst = s[s.size() - 1];
for (int i = s.size() - 1; i >= 1; i--) {
s[i] = s[i - 1];
}
s[0] = lst;
return s;
}
int main() {
string s;
while (cin >> s) {
mp[s] = true;
int cnt = 1;
for (int i = 0; i < s.size(); i++) {
s = shift(s);
if (!mp[s]) {
cnt++;
mp[s] = true;
}
}
mp.clear();
cout << cnt << endl;
}
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
Let's call a list of positive integers a_0, a_1, ..., a_{n-1} a power sequence if there is a positive integer c, so that for every 0 ≤ i ≤ n-1 then a_i = c^i.
Given a list of n positive integers a_0, a_1, ..., a_{n-1}, you are allowed to:
* Reorder the list (i.e. pick a permutation p of \{0,1,...,n - 1\} and change a_i to a_{p_i}), then
* Do the following operation any number of times: pick an index i and change a_i to a_i - 1 or a_i + 1 (i.e. increment or decrement a_i by 1) with a cost of 1.
Find the minimum cost to transform a_0, a_1, ..., a_{n-1} into a power sequence.
Input
The first line contains an integer n (3 ≤ n ≤ 10^5).
The second line contains n integers a_0, a_1, ..., a_{n-1} (1 ≤ a_i ≤ 10^9).
Output
Print the minimum cost to transform a_0, a_1, ..., a_{n-1} into a power sequence.
Examples
Input
3
1 3 2
Output
1
Input
3
1000000000 1000000000 1000000000
Output
1999982505
Note
In the first example, we first reorder \{1, 3, 2\} into \{1, 2, 3\}, then increment a_2 to 4 with cost 1 to get a power sequence \{1, 2, 4\}.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const long long MOD = 998244353;
const long long inf = 1e18;
const long long MAX = 2e5 + 1;
inline long long add(long long a, long long b) {
return ((a % mod) + (b % mod)) % mod;
}
inline long long sub(long long a, long long b) {
return ((a % mod) - (b % mod) + mod) % mod;
}
inline long long mul(long long a, long long b) {
return ((a % mod) * (b % mod)) % mod;
}
long long pwr(long long x, long long n) {
x = x % mod;
if (!n) return 1;
if (n & 1)
return mul(x, pwr(mul(x, x), (n - 1) / 2));
else
return pwr(mul(x, x), n / 2);
}
long long modinv(long long n) { return pwr(n, mod - 2); }
long long inv(long long i) {
if (i == 1) return 1;
return (MOD - (MOD / i) * inv(MOD % i) % MOD) % MOD;
}
bool f(int a, int b) { return a > b; }
struct cmp {
bool operator()(const int &k1, const int &k2) { return k1 > k2; }
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int tt = 1;
while (tt--) {
long long n;
cin >> n;
vector<long long> v(n);
for (long long i = 0; i < n; i++) cin >> v[i];
sort(v.begin(), v.end());
long long tot = LLONG_MAX;
long long start = 1, cnt = 1, prev;
while (start <= v[n - 1]) {
cnt++;
prev = start;
start = pow(cnt, n - 1);
if (start < 0) break;
}
if (start < prev) cnt--;
for (long long i = 1; i <= cnt; i++) {
long long ans = 0;
for (long long j = 0; j < n; j++) {
ans += abs(v[j] - pow(i, j));
}
tot = min(tot, ans);
}
cout << tot << "\n";
}
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
During the last Sereja's Codesecrof round the server crashed many times, so the round was decided to be made unrated for some participants.
Let's assume that n people took part in the contest. Let's assume that the participant who got the first place has rating a1, the second place participant has rating a2, ..., the n-th place participant has rating an. Then changing the rating on the Codesecrof site is calculated by the formula <image>.
After the round was over, the Codesecrof management published the participants' results table. They decided that if for a participant di < k, then the round can be considered unrated for him. But imagine the management's surprise when they found out that the participants' rating table is dynamic. In other words, when some participant is removed from the rating, he is removed from the results' table and the rating is recalculated according to the new table. And of course, all applications for exclusion from the rating are considered in view of the current table.
We know that among all the applications for exclusion from the rating the first application to consider is from the participant with the best rank (the rank with the minimum number), for who di < k. We also know that the applications for exclusion from rating were submitted by all participants.
Now Sereja wonders, what is the number of participants to be excluded from the contest rating, and the numbers of the participants in the original table in the order of their exclusion from the rating. Pay attention to the analysis of the first test case for a better understanding of the statement.
Input
The first line contains two integers n, k (1 ≤ n ≤ 2·105, - 109 ≤ k ≤ 0). The second line contains n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 109) — ratings of the participants in the initial table.
Output
Print the numbers of participants in the order in which they were removed from the table. Print the initial numbers of the participants, that is, the numbers that the participants had in the initial table.
Examples
Input
5 0
5 3 4 1 2
Output
2
3
4
Input
10 -10
5 5 1 7 5 1 2 4 9 2
Output
2
4
5
7
8
9
Note
Consider the first test sample.
1. Initially the sequence of the contest participants' ratings equals [5, 3, 4, 1, 2]. You can use this sequence to calculate the sequence of rating changes: [0, -9, -13, 8, 14]. According to the problem statement, the application of the participant who won the second place will be considered first.
2. As soon as the second place winner is out from the ratings, the participants' rating sequence will equal [5, 4, 1, 2]. By this sequence you can count the new sequence of rating changes: [0, -8, 2, 6]. According to the problem statement, the application of the participant who won the second place will be considered. Initially this participant won third place.
3. The new rating sequence equals [5, 1, 2], the new sequence of rating changes equals [0, -1, 1]. The second place participant's application is taken into consideration, initially this participant won the fourth place.
4. The new rating sequence equals [5, 2], the new sequence of rating changes equals [0, 0]. No more applications will be considered.
Thus, you should print 2, 3, 4.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MOD(1000000007);
const int INF((1 << 30) - 1);
const int MAXN(200005);
long long a[MAXN], d[MAXN];
int main() {
int n, k;
scanf("%d%d", &n, &k);
int m = 1, p = n;
cin >> a[1];
d[1] = 0;
for (int i = 2; i <= n; i++) {
int x;
scanf("%d", &x);
long long tmp = d[m] + a[m] * (m - 1);
if (tmp - (long long)(m) * (p - (m + 1)) * x >= k) {
m++;
a[m] = x;
d[m] = tmp;
} else {
printf("%d\n", i);
p--;
}
}
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
We have a sequence of length N consisting of non-negative integers. Consider performing the following operation on this sequence until the largest element in this sequence becomes N-1 or smaller.
* Determine the largest element in the sequence (if there is more than one, choose one). Decrease the value of this element by N, and increase each of the other elements by 1.
It can be proved that the largest element in the sequence becomes N-1 or smaller after a finite number of operations.
You are given an integer K. Find an integer sequence a_i such that the number of times we will perform the above operation is exactly K. It can be shown that there is always such a sequence under the constraints on input and output in this problem.
Constraints
* 0 ≤ K ≤ 50 \times 10^{16}
Input
Input is given from Standard Input in the following format:
K
Output
Print a solution in the following format:
N
a_1 a_2 ... a_N
Here, 2 ≤ N ≤ 50 and 0 ≤ a_i ≤ 10^{16} + 1000 must hold.
Examples
Input
0
Output
4
3 3 3 3
Input
1
Output
3
1 0 3
Input
2
Output
2
2 2
Input
3
Output
7
27 0 0 0 0 0 0
Input
1234567894848
Output
10
1000 193 256 777 0 1 1192 1234567891011 48 425
### Response
```cpp
#include <iostream>
#include <stdio.h>
using namespace std;
typedef long long LL;
const int MAX_N = 56;
LL a[MAX_N];
int main () {
LL n=50;
LL k;
scanf("%lld",&k);
for (int i=1;n>=i;i++) {
a[i] = (n-1) + (k/n);
}
k%=n;
for (int i=1;k>=i;i++) {
a[i] += (k + -(k-1));
}
for (int i=k+1;n>=i;i++) {
a[i] += (-k);
}
puts("50");
for (int i=1;n>=i;i++) {
if (i!=1) printf(" ");
printf("%lld",a[i]);
}
puts("");
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
In the country of Never, there are n cities and a well-developed road system. There is exactly one bidirectional road between every pair of cities, thus, there are as many as <image> roads! No two roads intersect, and no road passes through intermediate cities. The art of building tunnels and bridges has been mastered by Neverians.
An independent committee has evaluated each road of Never with a positive integer called the perishability of the road. The lower the road's perishability is, the more pleasant it is to drive through this road.
It's the year of transport in Never. It has been decided to build a museum of transport in one of the cities, and to set a single signpost directing to some city (not necessarily the one with the museum) in each of the other cities. The signposts must satisfy the following important condition: if any Neverian living in a city without the museum starts travelling from that city following the directions of the signposts, then this person will eventually arrive in the city with the museum.
Neverians are incredibly positive-minded. If a Neverian travels by a route consisting of several roads, he considers the perishability of the route to be equal to the smallest perishability of all the roads in this route.
The government of Never has not yet decided where to build the museum, so they consider all n possible options. The most important is the sum of perishabilities of the routes to the museum city from all the other cities of Never, if the travelers strictly follow the directions of the signposts. The government of Never cares about their citizens, so they want to set the signposts in a way which minimizes this sum. Help them determine the minimum possible sum for all n possible options of the city where the museum can be built.
Input
The first line contains a single integer n (2 ≤ n ≤ 2000) — the number of cities in Never.
The following n - 1 lines contain the description of the road network. The i-th of these lines contains n - i integers. The j-th integer in the i-th line denotes the perishability of the road between cities i and i + j.
All road perishabilities are between 1 and 109, inclusive.
Output
For each city in order from 1 to n, output the minimum possible sum of perishabilities of the routes to this city from all the other cities of Never if the signposts are set in a way which minimizes this sum.
Examples
Input
3
1 2
3
Output
2
2
3
Input
6
2 9 9 6 6
7 1 9 10
9 2 5
4 10
8
Output
6
5
7
5
7
11
Note
The first example is explained by the picture below. From left to right, there is the initial road network and the optimal directions of the signposts in case the museum is built in city 1, 2 and 3, respectively. The museum city is represented by a blue circle, the directions of the signposts are represented by green arrows.
For instance, if the museum is built in city 3, then the signpost in city 1 must be directed to city 3, while the signpost in city 2 must be directed to city 1. Then the route from city 1 to city 3 will have perishability 2, while the route from city 2 to city 3 will have perishability 1. The sum of perishabilities of these routes is 3.
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 2005;
int n, c[N][N], d[N];
bool vis[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n;
int mn = 1e9;
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
cin >> c[i][j];
c[j][i] = c[i][j];
mn = min(mn, c[i][j]);
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) c[i][j] -= mn;
}
for (int i = 1; i <= n; i++) {
d[i] = 1e9;
for (int j = 1; j <= n; j++)
if (i != j) d[i] = min(d[i], c[i][j] * 2);
}
for (int rep = 1; rep <= n; rep++) {
int j = -1;
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
if (j == -1 || d[i] < d[j]) j = i;
}
}
vis[j] = true;
for (int i = 1; i <= n; i++) {
if (i == j) continue;
if (d[i] > d[j] + c[i][j]) d[i] = d[j] + c[i][j];
}
}
for (int i = 1; i <= n; i++) cout << 1ll * (n - 1) * mn + d[i] << '\n';
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
You are given an integer m, and a list of n distinct integers between 0 and m - 1.
You would like to construct a sequence satisfying the properties:
* Each element is an integer between 0 and m - 1, inclusive.
* All prefix products of the sequence modulo m are distinct.
* No prefix product modulo m appears as an element of the input list.
* The length of the sequence is maximized.
Construct any sequence satisfying the properties above.
Input
The first line of input contains two integers n and m (0 ≤ n < m ≤ 200 000) — the number of forbidden prefix products and the modulus.
If n is non-zero, the next line of input contains n distinct integers between 0 and m - 1, the forbidden prefix products. If n is zero, this line doesn't exist.
Output
On the first line, print the number k, denoting the length of your sequence.
On the second line, print k space separated integers, denoting your sequence.
Examples
Input
0 5
Output
5
1 2 4 3 0
Input
3 10
2 9 1
Output
6
3 9 2 9 8 0
Note
For the first case, the prefix products of this sequence modulo m are [1, 2, 3, 4, 0].
For the second case, the prefix products of this sequence modulo m are [3, 7, 4, 6, 8, 0].
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int M = 2e5;
bool ban[M], vis[M + 1];
int m, nxt[M + 1], f[M + 1];
vector<int> e[M + 1];
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int exgcd(int a, int b, int& x, int& y) {
int d;
if (b) {
d = exgcd(b, a % b, y, x);
y -= a / b * x;
} else {
x = 1;
y = 0;
d = a;
}
return d;
}
inline int solve(int a, int b) {
int x, y, d = exgcd(a, m, x, y);
assert(b % d == 0);
return (long long)b / d * (x + m) % m;
}
int dfs(int x) {
if (vis[x]) return f[x];
vis[x] = true;
f[x] = e[x].size();
nxt[x] = -1;
for (int y = 2 * x; y <= m; y += x)
if (m % y == 0) {
int t = e[x].size() + dfs(y);
if (t > f[x]) {
f[x] = t;
nxt[x] = y;
}
}
return f[x];
}
int main() {
int n;
scanf("%d%d", &n, &m);
for (int i = (0), i_end = (n); i < i_end; ++i) {
int x;
scanf("%d", &x);
ban[x] = true;
}
for (int i = (0), i_end = (m); i < i_end; ++i)
if (!ban[i]) e[gcd(i, m)].push_back(i);
dfs(1);
printf("%d\n", f[1]);
int p = 1;
for (int x = 1; x != -1; x = nxt[x]) {
for (int i = (0), i_end = (e[x].size()); i < i_end; ++i) {
int t = solve(p, e[x][i]);
printf("%d ", t);
p = e[x][i];
}
}
if (f[1]) puts("");
return 0;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
Little Chris knows there's no fun in playing dominoes, he thinks it's too random and doesn't require skill. Instead, he decided to play with the dominoes and make a "domino show".
Chris arranges n dominoes in a line, placing each piece vertically upright. In the beginning, he simultaneously pushes some of the dominoes either to the left or to the right. However, somewhere between every two dominoes pushed in the same direction there is at least one domino pushed in the opposite direction.
After each second, each domino that is falling to the left pushes the adjacent domino on the left. Similarly, the dominoes falling to the right push their adjacent dominoes standing on the right. When a vertical domino has dominoes falling on it from both sides, it stays still due to the balance of the forces. The figure shows one possible example of the process.
<image>
Given the initial directions Chris has pushed the dominoes, find the number of the dominoes left standing vertically at the end of the process!
Input
The first line contains a single integer n (1 ≤ n ≤ 3000), the number of the dominoes in the line. The next line contains a character string s of length n. The i-th character of the string si is equal to
* "L", if the i-th domino has been pushed to the left;
* "R", if the i-th domino has been pushed to the right;
* ".", if the i-th domino has not been pushed.
It is guaranteed that if si = sj = "L" and i < j, then there exists such k that i < k < j and sk = "R"; if si = sj = "R" and i < j, then there exists such k that i < k < j and sk = "L".
Output
Output a single integer, the number of the dominoes that remain vertical at the end of the process.
Examples
Input
14
.L.R...LR..L..
Output
4
Input
5
R....
Output
0
Input
1
.
Output
1
Note
The first example case is shown on the figure. The four pieces that remain standing vertically are highlighted with orange.
In the second example case, all pieces fall down since the first piece topples all the other pieces.
In the last example case, a single piece has not been pushed in either direction.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int r[n];
string s;
cin >> s;
const int inf = 1e9;
int dis = inf;
for (int i = 0; i < n; i++)
if (s[i] == 'R')
r[i] = dis = 0;
else if (s[i] == 'L')
r[i] = dis = inf;
else
r[i] = dis = min(dis + 1, inf);
dis = inf;
int ans = 0;
for (int i = n - 1; i >= 0; i--) {
if (s[i] == 'L')
dis = 0;
else if (s[i] == 'R')
dis = inf;
else
dis = min(dis + 1, inf);
ans += (dis == r[i]);
}
cout << ans << endl;
return 0;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
A famous sculptor Cicasso goes to a world tour!
Well, it is not actually a world-wide. But not everyone should have the opportunity to see works of sculptor, shouldn't he? Otherwise there will be no any exclusivity. So Cicasso will entirely hold the world tour in his native country — Berland.
Cicasso is very devoted to his work and he wants to be distracted as little as possible. Therefore he will visit only four cities. These cities will be different, so no one could think that he has "favourites". Of course, to save money, he will chose the shortest paths between these cities. But as you have probably guessed, Cicasso is a weird person. Although he doesn't like to organize exhibitions, he likes to travel around the country and enjoy its scenery. So he wants the total distance which he will travel to be as large as possible. However, the sculptor is bad in planning, so he asks you for help.
There are n cities and m one-way roads in Berland. You have to choose four different cities, which Cicasso will visit and also determine the order in which he will visit them. So that the total distance he will travel, if he visits cities in your order, starting from the first city in your list, and ending in the last, choosing each time the shortest route between a pair of cities — will be the largest.
Note that intermediate routes may pass through the cities, which are assigned to the tour, as well as pass twice through the same city. For example, the tour can look like that: <image>. Four cities in the order of visiting marked as overlines: [1, 5, 2, 4].
Note that Berland is a high-tech country. So using nanotechnologies all roads were altered so that they have the same length. For the same reason moving using regular cars is not very popular in the country, and it can happen that there are such pairs of cities, one of which generally can not be reached by car from the other one. However, Cicasso is very conservative and cannot travel without the car. Choose cities so that the sculptor can make the tour using only the automobile. It is guaranteed that it is always possible to do.
Input
In the first line there is a pair of integers n and m (4 ≤ n ≤ 3000, 3 ≤ m ≤ 5000) — a number of cities and one-way roads in Berland.
Each of the next m lines contains a pair of integers ui, vi (1 ≤ ui, vi ≤ n) — a one-way road from the city ui to the city vi. Note that ui and vi are not required to be distinct. Moreover, it can be several one-way roads between the same pair of cities.
Output
Print four integers — numbers of cities which Cicasso will visit according to optimal choice of the route. Numbers of cities should be printed in the order that Cicasso will visit them. If there are multiple solutions, print any of them.
Example
Input
8 9
1 2
2 3
3 4
4 1
4 5
5 6
6 7
7 8
8 5
Output
2 1 8 7
Note
Let d(x, y) be the shortest distance between cities x and y. Then in the example d(2, 1) = 3, d(1, 8) = 7, d(8, 7) = 3. The total distance equals 13.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int _x;
scanf("%d", &_x);
return _x;
}
const int INF = (int)1e9;
const int mod = (int)1e9 + 7;
const int maxn = (int)3e3 + 5;
const int logn = 20;
const int sqrtn = 1e3 + 5;
int N, M, mark[maxn][maxn];
bool used[maxn], used2[maxn][maxn];
vector<int> road[maxn];
vector<pair<int, int> > q[maxn], w[maxn];
void sp(int root) {
memset(used, 0, sizeof used);
mark[root][root] = 0;
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
pq;
pq.push(pair<int, int>(0, root));
while (!pq.empty()) {
int cur = pq.top().second;
int cost = pq.top().first;
pq.pop();
used[cur] = 1;
for (int i = 0; i < road[cur].size(); i++) {
if (cost + 1 < mark[root][road[cur][i]]) {
mark[root][road[cur][i]] = cost + 1;
pq.push(pair<int, int>(mark[root][road[cur][i]], road[cur][i]));
}
}
while (!pq.empty() && used[pq.top().second]) pq.pop();
if (pq.empty()) break;
}
for (int i = 1; i <= N; i++)
if (i != root && mark[root][i] <= M) {
q[root].push_back(pair<int, int>(mark[root][i], i));
w[i].push_back(pair<int, int>(mark[root][i], root));
used2[root][i] = 1;
}
}
int main() {
memset(mark, 101, sizeof mark);
int maxx = -1, a1, a2, a3, a4;
N = read(), M = read();
for (int i = 1; i <= M; i++) {
int a = read(), b = read();
road[a].push_back(b);
}
for (int i = 1; i <= N; i++) sp(i);
for (int i = 1; i <= N; i++)
sort(q[i].begin(), q[i].end()), sort(w[i].begin(), w[i].end());
for (int i = 1; i <= N; i++)
for (int j = 1; j <= N; j++) {
if (i == j || !used2[i][j]) continue;
for (int k = w[i].size() - 1; k >= max(0, (int)w[i].size() - 4); k--)
for (int l = q[j].size() - 1; l >= max(0, (int)q[j].size() - 4); l--) {
if (w[i][k].second == q[j][l].second || w[i][k].second == j ||
q[j][l].second == i)
continue;
int cur;
cur = mark[i][j] + w[i][k].first + q[j][l].first;
if (cur > maxx) {
maxx = cur;
a1 = w[i][k].second, a2 = i, a3 = j, a4 = q[j][l].second;
}
}
}
printf("%d %d %d %d\n", a1, a2, a3, a4);
return 0;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
Requirements
* All inputs are of non-negative integer value.
* T_{\text{max}} = 10000
* 200 \leq |V| \leq 400
* 1.5 |V| \leq |E| \leq 2 |V|
* 1 \leq u_{i}, v_{i} \leq |V| (1 \leq i \leq |E|)
* 1 \leq d_{u_i, v_i} \leq \lceil 4\sqrt{2|V|} \rceil (1 \leq i \leq |E|)
* The given graph has no self-loops / multiple edges and is guaranteed to be connected.
* 0 \leq N_{\text{new}} \leq 1
* 1 \leq \mathrm{new\\_id}_{i} \leq T_{\text{last}}+1 (1 \leq i \leq N_{\text{new}}). Note: If all orders are generated by the order generation rule as explained above, the total number of orders is at most T_{\text{last}}+1. Therefore, the possible range of \mathrm{new\\_id}_{i} should be from 1 to T_{\text{last}}+1.
* 2 \leq \mathrm{dst}_i \leq |V| (1 \leq i \leq N_{\text{new}})
* The order IDs \mathrm{new\\_{id}}_i are unique.
Input Format
Input is provided in the following form:
|V| |E|
u_{1} v_{1} d_{u_{1}, v_{1}}
u_{2} v_{2} d_{u_{2}, v_{2}}
:
u_{|E|} v_{|E|} d_{u_{|E|}, v_{|E|}}
T_{\text{max}}
\mathrm{info}_{0}
\mathrm{info}_{1}
:
\mathrm{info}_{T_{\text{max}}-1}
* In the first line |V| denotes the number of vertices, while |E| denotes the number of edges.
* The following |E| lines denote the edges of the graph. In particular, in the ith line u_{i} and v_{i} denote the edge connecting u_{i} and v_{i} and d_{u_{i}, v_{i}} the corresponding distance.
* The following line denotes the number of steps T_{\text{max}}.
In the following line, \mathrm{info}_t is information about the order from the customer that occurs at time t. \mathrm{info}_t is given in the form:
N_{\text{new}}
\mathrm{new\_id}_1 \mathrm{dst}_1
\mathrm{new\_id}_2 \mathrm{dst}_2
\vdots
\mathrm{new\_id}_{N_{\text{new}}} \mathrm{dst}_{N_{\text{new}}}
* N_{\text{new}} represents the number of new orders which appear at time t.
* The next N_{\text{new}} lines give the newly generated order information. The i-th order information indicates that the order ID \mathrm{new\\_{id}}_i of the new order, while \mathrm{dst}_i denotes the vertex to which the customer wishes the order to be delivered.
* Note: If N_{\text{new}}=0, there are no new lines.
Output Format
The Output expects T_{\text{max}} integers in the format specified below.
\mathrm{command}_{0}
\mathrm{command}_{1}
:
\mathrm{command}_{T_{\text{max}}-1}
In particular, \mathrm{command}_{i} shall specify the movement of the delivery car by using one of the following two options:
1) `stay`, if the car shall not move:
-1
2) `move w`, if the car shall be moved one step towards the neighboring vertex w
w
Note that in case of 2) w has to satisfy the following conditions:
* w \in V
* If the car is at vertex u: \left\\{ u, w \right\\} \in E .
* If the car is on the edge \left\\{ u, v \right\\}, w must either satisfy u = w or v = w.
* * *
Examples
Input
Output
Input
5 7
1 2 5
5 3 4
2 4 8
1 5 1
2 3 3
4 5 3
4 3 9
4
1
1 2
1
2 5
1
3 4
0
Output
2
-1
1
5
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int, int> PII;
typedef vector<int> VI;
#define MP make_pair
#define PB push_back
#define X first
#define Y second
#define FOR(i, a, b) for(int i = (a); i < (b); ++i)
#define RFOR(i, b, a) for(int i = (b) - 1; i >= (a); --i)
#define ITER(it, a) for(__typeof(a.begin()) it = a.begin(); it != a.end(); ++it)
#define ALL(a) a.begin(), a.end()
#define SZ(a) (int)((a).size())
#define FILL(a, value) memset(a, value, sizeof(a))
#define debug(a) cerr << #a << " = " << a << endl;
const double PI = acos(-1.0);
const LL INF = 1e9;
const LL LINF = INF * INF;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
inline int random(int l, int r)
{
return l + rng() % (r - l + 1);
}
const int T = 10000;
int Tmax;
const int N = 400 + 7;
const int M = 800 + 7;
int p[N];
int find(int u)
{
return p[u] = u == p[u] ? u : find(p[u]);
}
bool unite(int u , int v)
{
u = find(u) , v = find(v);
if(u != v)
{
p[v] = u;
return true;
}
return false;
}
int n, m;
vector<PII> g[N];
pair<int, PII> edges[M];
PII order[T];
VI needed[N];
int dist[N][N];
int parent[N][N];
int G[N][N];
int number_of_orders_on_suf[T + 1];
inline int waiting_orders(int l, int r)
{
r = min(r , T - 1);
if (l > r) return 0;
return number_of_orders_on_suf[r] - (l ? number_of_orders_on_suf[l - 1] : 0);
}
void graph_input()
{
cin >> n >> m;
FOR(i, 1, n + 1) FOR(j, 1, n + 1) G[i][j] = INF;
FOR(i, 1, n + 1) G[i][i] = 0;
FOR(i, 0, m)
{
int u, v, w;
cin >> u >> v >> w;
G[u][v] = G[v][u] = w;
g[u].PB({v, w});
g[v].PB({u, w});
edges[i] = {w, {u, v}};
}
}
int de;
void order_input()
{
cin >> Tmax;
FILL(order, -1);
int suma = 0;
double maxCof = 0;
FOR(i, 0, Tmax)
{
int t;
cin >> t;
suma += t;
if(suma / (i + 1.) > maxCof)
{
maxCof = suma / (i + 1.0);
de = i;
}
if (i)
number_of_orders_on_suf[i] = number_of_orders_on_suf[i - 1];
if (t == 0) continue;
number_of_orders_on_suf[i]++;
int id, dst;
cin >> id >> dst;
order[i] = {id, dst};
needed[dst].PB(i);
}
cerr << de << endl;
}
void preprocess()
{
FOR(i, 1, n + 1)
{
FOR(j, 1, n + 1) dist[i][j] = INF;
dist[i][i] = 0;
set<PII> S;
FOR(j, 1, n + 1)
S.insert({dist[i][j], j});
while(SZ(S))
{
int v = S.begin()->Y;
S.erase(S.begin());
for(auto e: g[v])
{
int to = e.X, len = e.Y;
if (dist[i][to] <= dist[i][v] + len) continue;
parent[i][to] = v;
S.erase({dist[i][to], to});
dist[i][to] = dist[i][v] + len;
S.insert({dist[i][to], to});
}
}
}
}
vector<int> path(int from, int to)
{
vector<int> res;
while(from != to)
{
res.PB(to);
to = parent[from][to];
}
res.PB(from);
reverse(ALL(res));
return res;
}
double cof[N];
vector<int> go(vector<int>& orders, int start_time)
{
int curr_vertex = 1;
vector<int> res;
const int Magic = 47;
vector<int> ostov;
ostov.PB(1);
while(SZ(orders))
{
memset(cof , 0 , sizeof cof);
for(auto ord : orders)
cof[order[ord].Y]++;
int to = -1;
for(auto i: orders)
if (to == -1 || dist[curr_vertex][to] / cof[to] > dist[curr_vertex][order[i].Y] / cof[order[i].Y] ||
(cof[order[i].Y] > 6 && cof[to] < cof[order[i].Y] && dist[curr_vertex][order[i].Y] < 7) )
to = order[i].Y;
ostov.PB(to);
int curr_time = start_time + SZ(res);
int nxt_time = start_time + SZ(res) + dist[curr_vertex][to];
//cerr << curr_time << " " << nxt_time << '\n';
if (curr_vertex != 1 && dist[curr_vertex][to] / cof[to] > dist[curr_vertex][1] * 7 / (waiting_orders(start_time , curr_time) + 1)
)
to = 1;
vector<int> way = path(curr_vertex, to);
FOR(i, 0, SZ(way) - 1)
FOR(j, 0, G[way[i]][way[i + 1]])
res.PB(way[i + 1]);
curr_vertex = to;
sort(ALL(way));
vector<int> nxt;
for(auto i: orders)
{
auto it = lower_bound(ALL(way), order[i].Y);
if (it != way.end() && *it == order[i].Y) continue;
nxt.PB(i);
}
orders = nxt;
if (to == 1) break;
}
vector<int> way = path(curr_vertex, 1);
FOR(i, 0, SZ(way) - 1)
FOR(j, 0, G[way[i]][way[i + 1]])
res.PB(way[i + 1]);
//int hujna = 0;
//cerr << SZ(res) << " " << hujna << endl;
return res;
}
int main()
{
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
graph_input();
order_input();
preprocess();
vector<int> res;
vector<int> orders;
int Magic = 1;
int chas = 0;
while(chas < Tmax)
{
if (order[chas].X != -1)
orders.PB(chas);
if (SZ(orders) >= Magic)
{
auto tut = go(orders, chas);
for(auto i: tut) res.PB(i);
if (SZ(res) >= Tmax)
{
res.resize(Tmax);
break;
}
FOR(i, 0, SZ(tut))
{
chas++;
if (order[chas].X != -1) orders.PB(chas);
}
continue;
}
chas++;
res.PB(-1);
}
for(auto i: res) cout << i << endl;
//cerr << "Time elapsed: " << clock() / (double)CLOCKS_PER_SEC << endl;
return 0;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
Tokitsukaze and CSL are playing a little game of stones.
In the beginning, there are n piles of stones, the i-th pile of which has a_i stones. The two players take turns making moves. Tokitsukaze moves first. On each turn the player chooses a nonempty pile and removes exactly one stone from the pile. A player loses if all of the piles are empty before his turn, or if after removing the stone, two piles (possibly empty) contain the same number of stones. Supposing that both players play optimally, who will win the game?
Consider an example: n=3 and sizes of piles are a_1=2, a_2=3, a_3=0. It is impossible to choose the empty pile, so Tokitsukaze has two choices: the first and the second piles. If she chooses the first pile then the state will be [1, 3, 0] and it is a good move. But if she chooses the second pile then the state will be [2, 2, 0] and she immediately loses. So the only good move for her is to choose the first pile.
Supposing that both players always take their best moves and never make mistakes, who will win the game?
Note that even if there are two piles with the same number of stones at the beginning, Tokitsukaze may still be able to make a valid first move. It is only necessary that there are no two piles with the same number of stones after she moves.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^5) — the number of piles.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_1, a_2, …, a_n ≤ 10^9), which mean the i-th pile has a_i stones.
Output
Print "sjfnb" (without quotes) if Tokitsukaze will win, or "cslnb" (without quotes) if CSL will win. Note the output characters are case-sensitive.
Examples
Input
1
0
Output
cslnb
Input
2
1 0
Output
cslnb
Input
2
2 2
Output
sjfnb
Input
3
2 3 1
Output
sjfnb
Note
In the first example, Tokitsukaze cannot take any stone, so CSL will win.
In the second example, Tokitsukaze can only take a stone from the first pile, and then, even though they have no stone, these two piles will have the same number of stones, which implies CSL will win.
In the third example, Tokitsukaze will win. Here is one of the optimal ways:
* Firstly, Tokitsukaze can choose the first pile and take a stone from that pile.
* Then, CSL can only choose the first pile, because if he chooses the second pile, he will lose immediately.
* Finally, Tokitsukaze can choose the second pile, and then CSL will have no choice but to lose.
In the fourth example, they only have one good choice at any time, so Tokitsukaze can make the game lasting as long as possible and finally win.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n;
cin >> n;
long long int arr[n];
map<long long int, long long int> m;
for (long long int i = 0; i < n; i++) {
cin >> arr[i];
m[arr[i]]++;
}
vector<long long int> v;
for (auto k : m) {
if (k.second >= 2) v.push_back(k.first);
}
if (v.size() >= 2) {
cout << "cslnb" << endl;
return 0;
}
long long int player = 1;
if (v.size() == 1) {
long long int val = v[0];
m[val]--;
val--;
if (val < 0 || m.find(val) != m.end() || m[val + 1] >= 2) {
cout << "cslnb" << endl;
return 0;
}
m[val]++;
player = 2;
}
v.clear();
for (auto k : m) v.push_back(k.first);
long long int mn = 0;
for (auto k : v) {
if (k == mn) {
mn++;
continue;
}
long long int diff = k - mn;
if (diff & 1) {
if (player == 2)
player = 1;
else
player = 2;
}
mn++;
}
if (player == 1)
cout << "cslnb" << endl;
else
cout << "sjfnb" << endl;
return 0;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
problem
President K decided to make a flag for IOI 2016 in Russia. Chairman K first took out the old flag from the warehouse. This flag is divided into squares of N rows and M columns, and each square is painted in one of white, blue, and red.
Chairman K is trying to repaint some of the squares on this flag to make it the Russian flag. However, the Russian flag in this problem is as follows.
* Several lines (one or more lines) from the top are all painted in white.
* The next few lines (one or more lines) are all painted in blue.
* All the cells in the other lines (one or more lines) are painted in red.
Find the minimum number of squares that President K needs to repaint to turn the old flag into a Russian flag.
input
The input consists of 1 + N lines.
On the first line, two integers N and M (3 ≤ N ≤ 50, 3 ≤ M ≤ 50) are written separated by a blank. This means that the flags are separated by N rows and M columns.
The following N lines each contain a string of M characters, which represents the color information painted in the squares of the old flag. The jth character (1 ≤ i ≤ N, 1 ≤ j ≤ M) on the i-th line of the N-line represents the color of the cell on the i-th line and j-th column of the old flag. It is either B'or'R'. 'W' stands for white,'B' stands for blue, and'R' stands for red.
output
Output in one line the minimum number of squares that President K needs to repaint to turn the old flag into a Russian flag.
Input / output example
Input example 1
4 5
WRWRW
BWRWB
WRWRW
RWBWR
Output example 1
11
Input example 2
6 14
WWWWWWWWWWWWWW
WBBBWWRRWWBBBW
WWBWWRRRRWWBWW
BWBWWRRRRWWBWW
WBBWWWRRWWBBBW
WWWWWWWWWWWWWW
Output example 2
44
In I / O example 1, the old flag is colored as shown in the figure below.
fig01
In the figure below, repaint the 11 squares with an'X'.
fig02
This makes it possible to make the Russian flag as shown in the figure below.
fig03
Since it is not possible to make a Russian flag by repainting less than 11 squares, 11 is output.
In I / O example 2, the old flag is colored as shown in the figure below.
fig04
Creative Commons License
Information Olympics Japan Committee work "15th Japan Information Olympics JOI 2015/2016 Qualifying Competition Tasks"
Example
Input
4 5
WRWRW
BWRWB
WRWRW
RWBWR
Output
11
### Response
```cpp
#include <stdio.h>
int H, W;
char a[100][100];
int tmp = 0, ans = 2500;
int main(void){
scanf("%d%d", &H, &W);
for (int i = 0; i < H; ++i){
scanf("%s", &a[i]);
}
for (int i = 1; i <= H - 2; ++i) {
for (int j = 1; j <= H - 1; ++j) {
for (int x = 1; x <= H; ++x) {
for (int y = 1; y <= W; ++y) {
if (x <= i) {
if (a[x - 1][y - 1] != 'W') {
tmp++;
}
}
else if (x <= j) {
if (a[x - 1][y - 1] != 'B') {
tmp++;
}
}
else {
if (a[x - 1][y - 1] != 'R') {
tmp++;
}
}
}
}
if (ans > tmp) { ans = tmp; }
tmp = 0;
}
}
printf("%d\n", ans);
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
Recently you've discovered a new shooter. They say it has realistic game mechanics.
Your character has a gun with magazine size equal to k and should exterminate n waves of monsters. The i-th wave consists of a_i monsters and happens from the l_i-th moment of time up to the r_i-th moments of time. All a_i monsters spawn at moment l_i and you have to exterminate all of them before the moment r_i ends (you can kill monsters right at moment r_i). For every two consecutive waves, the second wave starts not earlier than the first wave ends (though the second wave can start at the same moment when the first wave ends) — formally, the condition r_i ≤ l_{i + 1} holds. Take a look at the notes for the examples to understand the process better.
You are confident in yours and your character's skills so you can assume that aiming and shooting are instant and you need exactly one bullet to kill one monster. But reloading takes exactly 1 unit of time.
One of the realistic mechanics is a mechanic of reloading: when you reload you throw away the old magazine with all remaining bullets in it. That's why constant reloads may cost you excessive amounts of spent bullets.
You've taken a liking to this mechanic so now you are wondering: what is the minimum possible number of bullets you need to spend (both used and thrown) to exterminate all waves.
Note that you don't throw the remaining bullets away after eradicating all monsters, and you start with a full magazine.
Input
The first line contains two integers n and k (1 ≤ n ≤ 2000; 1 ≤ k ≤ 10^9) — the number of waves and magazine size.
The next n lines contain descriptions of waves. The i-th line contains three integers l_i, r_i and a_i (1 ≤ l_i ≤ r_i ≤ 10^9; 1 ≤ a_i ≤ 10^9) — the period of time when the i-th wave happens and the number of monsters in it.
It's guaranteed that waves don't overlap (but may touch) and are given in the order they occur, i. e. r_i ≤ l_{i + 1}.
Output
If there is no way to clear all waves, print -1. Otherwise, print the minimum possible number of bullets you need to spend (both used and thrown) to clear all waves.
Examples
Input
2 3
2 3 6
3 4 3
Output
9
Input
2 5
3 7 11
10 12 15
Output
30
Input
5 42
42 42 42
42 43 42
43 44 42
44 45 42
45 45 1
Output
-1
Input
1 10
100 111 1
Output
1
Note
In the first example:
* At the moment 2, the first wave occurs and 6 monsters spawn. You kill 3 monsters and start reloading.
* At the moment 3, the second wave occurs and 3 more monsters spawn. You kill remaining 3 monsters from the first wave and start reloading.
* At the moment 4, you kill remaining 3 monsters from the second wave.
In total, you'll spend 9 bullets.
In the second example:
* At moment 3, the first wave occurs and 11 monsters spawn. You kill 5 monsters and start reloading.
* At moment 4, you kill 5 more monsters and start reloading.
* At moment 5, you kill the last monster and start reloading throwing away old magazine with 4 bullets.
* At moment 10, the second wave occurs and 15 monsters spawn. You kill 5 monsters and start reloading.
* At moment 11, you kill 5 more monsters and start reloading.
* At moment 12, you kill last 5 monsters.
In total, you'll spend 30 bullets.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct node {
long long n;
bool f;
};
int N, K, L[2005], R[2005], A[2005];
unordered_map<int, node> dp[2005];
inline void rem(int a, int j, int &r, int &d) {
if (a <= j) {
r = j - a, d = 0;
} else {
int t = (a - j) % K;
d = (a - j) / K + (t ? 1 : 0), r = t ? K - t : 0;
}
}
inline bool judge(int i, int r, bool f, bool c) {
int n = R[i] - L[i];
if (f) {
n += (c || L[i] > R[i - 1]) ? 1 : 0;
return A[i] <= 1LL * n * K;
}
return A[i] <= 1LL * n * K + r;
}
int main() {
scanf("%d%d", &N, &K);
long long s = 0;
for (int i = 0; i < N; i++) {
scanf("%d%d%d", L + i, R + i, A + i);
s += A[i];
}
dp[0][K] = node{0, 0};
for (int i = 0; i < N; i++) {
for (unordered_map<int, node>::iterator it = dp[i].begin();
it != dp[i].end(); ++it) {
int j = it->first, r, d;
node &cur = it->second;
if (judge(i, j, 0, cur.f)) {
rem(A[i], j, r, d);
node &nxt = dp[i + 1][r];
if (!nxt.n || cur.n < nxt.n) {
nxt.n = cur.n, nxt.f = d < R[i] - L[i];
}
}
if (j < K) {
if (judge(i, 0, 1, cur.f)) {
rem(A[i], (cur.f || L[i] > R[i - 1]) ? K : 0, r, d);
node &nxt = dp[i + 1][r];
if (!nxt.n || cur.n + j < nxt.n || (cur.n + j == nxt.n && !nxt.f)) {
nxt.n = cur.n + j, nxt.f = d < R[i] - L[i];
}
}
}
}
}
long long res = LLONG_MAX;
for (unordered_map<int, node>::iterator it = dp[N].begin(); it != dp[N].end();
++it) {
res = min(res, it->second.n);
}
printf("%lld\n", res == LLONG_MAX ? -1 : res + s);
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
Let us define the beauty of a sequence (a_1,... ,a_n) as the number of pairs of two adjacent elements in it whose absolute differences are d. For example, when d=1, the beauty of the sequence (3, 2, 3, 10, 9) is 3.
There are a total of n^m sequences of length m where each element is an integer between 1 and n (inclusive). Find the beauty of each of these n^m sequences, and print the average of those values.
Constraints
* 0 \leq d < n \leq 10^9
* 2 \leq m \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
n m d
Output
Print the average of the beauties of the sequences of length m where each element is an integer between 1 and n. The output will be judged correct if the absolute or relative error is at most 10^{-6}.
Examples
Input
2 3 1
Output
1.0000000000
Input
1000000000 180707 0
Output
0.0001807060
### Response
```cpp
#include "bits/stdc++.h"
using namespace std;
int main() {
double n, m, d;
cin >> n >> m >> d;
if (d == 0) {
cout << (m - 1) / n;
}
else {
printf("%8f",(m - 1) * 2 * (n - d) / (n * n));
}
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
It's the turn of the year, so Bash wants to send presents to his friends. There are n cities in the Himalayan region and they are connected by m bidirectional roads. Bash is living in city s. Bash has exactly one friend in each of the other cities. Since Bash wants to surprise his friends, he decides to send a Pikachu to each of them. Since there may be some cities which are not reachable from Bash's city, he only sends a Pikachu to those friends who live in a city reachable from his own city. He also wants to send it to them as soon as possible.
He finds out the minimum time for each of his Pikachus to reach its destination city. Since he is a perfectionist, he informs all his friends with the time their gift will reach them. A Pikachu travels at a speed of 1 meters per second. His friends were excited to hear this and would be unhappy if their presents got delayed. Unfortunately Team Rocket is on the loose and they came to know of Bash's plan. They want to maximize the number of friends who are unhappy with Bash.
They do this by destroying exactly one of the other n - 1 cities. This implies that the friend residing in that city dies, so he is unhappy as well.
Note that if a city is destroyed, all the roads directly connected to the city are also destroyed and the Pikachu may be forced to take a longer alternate route.
Please also note that only friends that are waiting for a gift count as unhappy, even if they die.
Since Bash is already a legend, can you help Team Rocket this time and find out the maximum number of Bash's friends who can be made unhappy by destroying exactly one city.
Input
The first line contains three space separated integers n, m and s (2 ≤ n ≤ 2·105, <image>, 1 ≤ s ≤ n) — the number of cities and the number of roads in the Himalayan region and the city Bash lives in.
Each of the next m lines contain three space-separated integers u, v and w (1 ≤ u, v ≤ n, u ≠ v, 1 ≤ w ≤ 109) denoting that there exists a road between city u and city v of length w meters.
It is guaranteed that no road connects a city to itself and there are no two roads that connect the same pair of cities.
Output
Print a single integer, the answer to the problem.
Examples
Input
4 4 3
1 2 1
2 3 1
2 4 1
3 1 1
Output
2
Input
7 11 2
1 2 5
1 3 5
2 4 2
2 5 2
3 6 3
3 7 3
4 6 2
3 4 2
6 7 3
4 5 7
4 7 7
Output
4
Note
In the first sample, on destroying the city 2, the length of shortest distance between pairs of cities (3, 2) and (3, 4) will change. Hence the answer is 2.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long n, m, s;
struct bian {
long long x, y, l, ls;
} b[600005];
vector<long long> c[600005];
long long t[600005], cnt, h[600005];
long long fa[600005], f[600005][22];
vector<long long> d[600005];
long long ss[600005];
inline long long read() {
register long long x = 0, ch = getchar();
while (!isdigit(ch)) ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return x;
}
void jb(long long x, long long y, long long l) {
cnt++;
b[cnt].x = x;
b[cnt].y = y;
b[cnt].l = l;
b[cnt].ls = t[x];
t[x] = cnt;
}
void rd() {
cin >> n >> m >> s;
for (long long i = 1; i <= m; i++) {
long long x, y, l;
x = read();
y = read();
l = read();
jb(x, y, l);
jb(y, x, l);
}
}
long long tiao(long long x, long long y) {
for (long long i = 20; i >= 0; i--)
if ((1 << i) <= y) {
y -= (1 << i);
x = f[x][i];
}
return x;
}
long long LCA(long long x, long long y) {
if (h[x] > h[y])
x = tiao(x, h[x] - h[y]);
else
y = tiao(y, h[y] - h[x]);
for (long long i = 20; i >= 0; i--) {
if (f[x][i] != f[y][i]) {
x = f[x][i];
y = f[y][i];
}
}
if (x == y)
return x;
else
return f[x][0];
}
bool vis[600005];
void beizeng(long long x) {
f[x][0] = fa[x];
for (long long i = 1; i <= 20; i++) f[x][i] = f[f[x][i - 1]][i - 1];
}
long long cnt_ = 0;
void dfs(long long x) {
vis[x] = 1;
long long k = 0;
for (long long i = 0; i < c[x].size(); i++) {
if (!vis[c[x][i]]) dfs(c[x][i]);
if (k == 0)
k = c[x][i];
else
k = LCA(k, c[x][i]);
}
fa[x] = k;
h[x] = h[fa[x]] + 1;
beizeng(x);
}
namespace dijk {
priority_queue<pair<long long, long long> > q;
long long dis[600005];
void qwq() {
memset(dis, 0x3f, sizeof(dis));
dis[s] = 0;
q.push(make_pair(0, s));
while (!q.empty()) {
long long x = q.top().second;
if (q.top().first != -dis[x]) {
q.pop();
continue;
}
q.pop();
for (long long i = t[x]; i != 0; i = b[i].ls) {
long long y = b[i].y;
if (dis[y] > dis[x] + b[i].l) {
dis[y] = dis[x] + b[i].l;
q.push(make_pair(-dis[y], y));
}
}
}
for (long long i = 1; i <= n; i++)
for (long long j = t[i]; j != 0; j = b[j].ls) {
long long y = b[j].y;
if (dis[y] == b[j].l + dis[i]) {
c[y].push_back(i);
}
}
}
} // namespace dijk
void dfs2(long long x) {
ss[x] = 1;
for (long long i = 0; i < d[x].size(); i++) {
long long y = d[x][i];
dfs2(y);
ss[x] += ss[y];
}
}
signed main() {
srand(time(0));
rd();
dijk::qwq();
for (long long i = 1; i <= n; i++)
if (!vis[i]) dfs(i);
for (long long i = 1; i <= n; i++) d[fa[i]].push_back(i);
dfs2(s);
long long ans = 0;
for (long long i = 1; i <= n; i++)
if (i != s) ans = max(ans, ss[i]);
cout << ans << "\n";
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
As you know, Hogwarts has four houses: Gryffindor, Hufflepuff, Ravenclaw and Slytherin. The sorting of the first-years into houses is done by the Sorting Hat. The pupils are called one by one in the alphabetical order, each of them should put a hat on his head and, after some thought, the hat solemnly announces the name of the house the student should enter.
At that the Hat is believed to base its considerations on the student's personal qualities: it sends the brave and noble ones to Gryffindor, the smart and shrewd ones — to Ravenclaw, the persistent and honest ones — to Hufflepuff and the clever and cunning ones — to Slytherin. However, a first year student Hermione Granger got very concerned about the forthcoming sorting. She studied all the literature on the Sorting Hat and came to the conclusion that it is much simpler than that. If the relatives of the student have already studied at Hogwarts, the hat puts the student to the same house, where his family used to study. In controversial situations, when the relatives studied in different houses or when they were all Muggles like Hermione's parents, then the Hat sorts the student to the house, to which the least number of first years has been sent at that moment. If there are several such houses, the choice is given to the student himself. Then the student can choose any of the houses, to which the least number of first years has been sent so far.
Hermione has already asked the students that are on the list before her about their relatives. Now she and her new friends Harry Potter and Ron Weasley want to find out into what house the Hat will put Hermione.
Input
The first input line contains an integer n (1 ≤ n ≤ 10000). It is the number of students who are in the list before Hermione. The next line contains n symbols. If all the relatives of a student used to study in the same house, then the i-th character in the string coincides with the first letter of the name of this house. Otherwise, the i-th symbol is equal to "?".
Output
Print all the possible houses where Hermione can be sent. The names of the houses should be printed in the alphabetical order, one per line.
Examples
Input
11
G????SS???H
Output
Gryffindor
Ravenclaw
Input
2
H?
Output
Gryffindor
Ravenclaw
Slytherin
Note
Consider the second example. There are only two students before Hermione. The first student is sent to Hufflepuff. The second disciple is given the choice between the houses where the least number of students has been sent, i.e. Gryffindor, Slytherin and Ravenclaw. If he chooses Gryffindor, Hermione is forced to choose between Ravenclaw and Slytherin, if he chooses Ravenclaw, Hermione will choose between Gryffindor and Slytherin, if he chooses Slytherin, Hermione will choose between Gryffindor and Ravenclaw. In the end, the following situation is possible (it depends on the choice of the second student and Hermione). Hermione will end up 1) in Gryffindor, 2) in Ravenclaw, 3) in Slytherin. Note that, despite the fact that in neither case Hermione will be given a choice between all the three options, they are all possible and they should all be printed in the answer. Hermione will not, under any circumstances, end up in Hufflepuff.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct node {
int a[4];
int t;
bool operator<(const node &T) const { return t > T.t; }
} tmp;
string s[4] = {"Gryffindor", "Hufflepuff", "Ravenclaw", "Slytherin"};
priority_queue<node> q;
map<pair<pair<int, int>, pair<int, int> >, int> mp;
pair<pair<int, int>, pair<int, int> > pp;
int main() {
for (int i = 0; i < 4; i++) tmp.a[i] = 0;
tmp.t = 0;
q.push(tmp);
int n;
char str[11111];
cin >> n >> str;
mp[make_pair(make_pair(0, 0), make_pair(0, 0))] = 1;
for (int i = 0; i < n; i++) {
if (str[i] == 'G') {
while (!q.empty()) {
tmp = q.top();
if (tmp.t == i + 1) break;
q.pop();
tmp.a[0]++;
pp = make_pair(make_pair(tmp.a[0], tmp.a[1]),
make_pair(tmp.a[2], tmp.a[3]));
if (mp[pp] == 0) {
tmp.t++;
mp[pp] = 1;
q.push(tmp);
}
}
}
if (str[i] == 'H') {
while (!q.empty()) {
tmp = q.top();
if (tmp.t == i + 1) break;
q.pop();
tmp.a[1]++;
pp = make_pair(make_pair(tmp.a[0], tmp.a[1]),
make_pair(tmp.a[2], tmp.a[3]));
if (mp[pp] == 0) {
tmp.t++;
mp[pp] = 1;
q.push(tmp);
}
}
}
if (str[i] == 'R') {
while (!q.empty()) {
tmp = q.top();
if (tmp.t == i + 1) break;
q.pop();
tmp.a[2]++;
pp = make_pair(make_pair(tmp.a[0], tmp.a[1]),
make_pair(tmp.a[2], tmp.a[3]));
if (mp[pp] == 0) {
tmp.t++;
mp[pp] = 1;
q.push(tmp);
}
}
}
if (str[i] == 'S') {
while (!q.empty()) {
tmp = q.top();
if (tmp.t == i + 1) break;
q.pop();
tmp.a[3]++;
pp = make_pair(make_pair(tmp.a[0], tmp.a[1]),
make_pair(tmp.a[2], tmp.a[3]));
if (mp[pp] == 0) {
tmp.t++;
mp[pp] = 1;
q.push(tmp);
}
}
}
if (str[i] == '?') {
while (!q.empty()) {
tmp = q.top();
if (tmp.t == i + 1) break;
q.pop();
int mn = (1 << 30);
for (int j = 0; j < 4; j++) mn = min(tmp.a[j], mn);
for (int j = 0; j < 4; j++)
if (tmp.a[j] == mn) {
node tt = tmp;
tt.a[j]++;
pp = make_pair(make_pair(tt.a[0], tt.a[1]),
make_pair(tt.a[2], tt.a[3]));
if (mp[pp] == 0) {
tt.t++;
mp[pp] = 1;
q.push(tt);
}
}
}
}
}
int has[4] = {0};
while (!q.empty()) {
tmp = q.top();
int mn = (1 << 30);
for (int j = 0; j < 4; j++) mn = min(tmp.a[j], mn);
for (int j = 0; j < 4; j++)
if (tmp.a[j] == mn) has[j] = 1;
q.pop();
}
for (int i = 0; i < 4; i++)
if (has[i]) cout << s[i] << endl;
return 0;
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
There is a cave consisting of N rooms and M one-directional passages. The rooms are numbered 1 through N.
Takahashi is now in Room 1, and Room N has the exit. The i-th passage connects Room s_i and Room t_i (s_i < t_i) and can only be traversed in the direction from Room s_i to Room t_i. It is known that, for each room except Room N, there is at least one passage going from that room.
Takahashi will escape from the cave. Each time he reaches a room (assume that he has reached Room 1 at the beginning), he will choose a passage uniformly at random from the ones going from that room and take that passage.
Aoki, a friend of Takahashi's, can block one of the passages (or do nothing) before Takahashi leaves Room 1. However, it is not allowed to block a passage so that Takahashi is potentially unable to reach Room N.
Let E be the expected number of passages Takahashi takes before he reaches Room N. Find the value of E when Aoki makes a choice that minimizes E.
Constraints
* 2 \leq N \leq 600
* N-1 \leq M \leq \frac{N(N-1)}{2}
* s_i < t_i
* If i != j, (s_i, t_i) \neq (s_j, t_j). (Added 21:23 JST)
* For every v = 1, 2, ..., N-1, there exists i such that v = s_i.
Input
Input is given from Standard Input in the following format:
N M
s_1 t_1
:
s_M t_M
Output
Print the value of E when Aoki makes a choice that minimizes E. Your output will be judged as correct when the absolute or relative error from the judge's output is at most 10^{-6}.
Examples
Input
4 6
1 4
2 3
1 3
1 2
3 4
2 4
Output
1.5000000000
Input
3 2
1 2
2 3
Output
2.0000000000
Input
10 33
3 7
5 10
8 9
1 10
4 6
2 5
1 7
6 10
1 4
1 3
8 10
1 5
2 6
6 9
5 6
5 8
3 6
4 8
2 7
2 9
6 7
1 2
5 9
6 8
9 10
3 9
7 8
4 5
2 10
5 7
3 5
4 7
4 9
Output
3.0133333333
### Response
```cpp
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(n);i++)
#define dbg(S) { int f=1; for(auto x:S) cerr<<(f?"[":", ")<<x, f=0; cerr<<"]\n"; }
using namespace std;
int main(){
int n,m; scanf("%d%d",&n,&m);
vector<vector<int>> G(n);
rep(i,m){
int u,v; scanf("%d%d",&u,&v); u--; v--;
G[u].emplace_back(v);
}
double dp0[600]={};
for(int u=n-2;u>=0;u--){
for(int v:G[u]){
dp0[u]+=dp0[v];
}
dp0[u]=dp0[u]/G[u].size()+1;
}
double ans=1e77;
double dp[600];
rep(i,n){
int j=-1;
for(int k:G[i]){ if(j==-1 || dp0[j]<dp0[k]) j=k; }
dp[n-1]=0;
for(int u=n-2;u>=0;u--){
dp[u]=0;
int deg=0;
for(int v:G[u]) if(u!=i || v!=j) {
dp[u]+=dp[v];
deg++;
}
dp[u]=dp[u]/deg+1;
}
ans=min(ans,dp[0]);
}
printf("%.15f\n",ans);
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
Twin adventurers Rin and Len are searching for treasure in the Mirror Cave. The cave has two pairs of rooms, the Hall of Mirrors, and an expensive treasure lies behind the door of the room.
For convenience, each of the two rooms is considered to have W × H cells arranged in a grid pattern. The outside of the room is surrounded by a wall. In addition, walls are installed in places inside the room, and it is not possible to enter the cells where the walls are located. To open the door to the treasure room, the two must move symmetrically to reach a particular cell at the same time. Moreover, if only one arrives first, the door will be locked and will not open.
Symmetrical movement means moving north and north, west and east, east and west, and south and south at the same time. However, it is recognized that the movement is symmetrical even in a situation where one has a wall at the end where it is trying to move and the other has no wall at the end. In this case, those with a wall will stay there, and those without a wall will move to the next cell.
As inputs, the initial position of the twins, the destination, and the placement of obstacles are given. Your job is to write a program to determine if the twins can open the door.
Input
The input consists of multiple datasets. Each dataset is given in the following format.
> W H
> RoomL1 RoomR1
> RoomL2 RoomR2
> ...
> RoomLH RoomRH
The first line gives two positive integers W, H (1 ≤ W, H ≤ 50) separated by a single space. After that, information on two rooms is given over H lines. RoomLi and RoomRi correspond to the i-th row of the left and right rooms, respectively. Both are strings of length W, with the jth character corresponding to the jth column of the room. Each character is one of the following:
* `.`: Freely moveable cell
* `#`: Cell with wall (cannot enter)
* `%`: Destination
* `R`: Initial position of Rin
* `L`: Initial position of Len
In each room, the first row corresponds to the north end of the room and the first row corresponds to the west end of the room. Also, each room always has exactly one destination, with exactly one initial position for Len in the left room and one for Rin in the right room.
The end of the input is indicated by a line containing two zeros separated by a blank.
Output
For each dataset, print Yes if the twins can open the door, and No if they can't.
Sample Input
5 5
% # ... ... #%
. #. #.. #. #.
. #. #.. #. #.
. #. #.. #. #.
... # L R # ...
3 2
.L. .R #
% .. .%.
4 1
L.%.% .. R
0 0
Output for the Sample Input
Yes
Yes
No
Example
Input
5 5
%#... ...#%
.#.#. .#.#.
.#.#. .#.#.
.#.#. .#.#.
...#L R#...
3 2
.L. .R#
%.. .%.
4 1
L.%. %..R
0 0
Output
Yes
Yes
No
### Response
```cpp
#include "bits/stdc++.h"
using namespace std;
#ifdef _DEBUG
#include "dump.hpp"
#else
#define dump(...)
#endif
//#define int long long
#define rep(i,a,b) for(int i=(a);i<(b);i++)
#define rrep(i,a,b) for(int i=(b)-1;i>=(a);i--)
#define all(c) begin(c),end(c)
const int INF = sizeof(int) == sizeof(long long) ? 0x3f3f3f3f3f3f3f3fLL : 0x3f3f3f3f;
const int MOD = (int)(1e9) + 7;
template<class T> bool chmax(T &a, const T &b) { if (a < b) { a = b; return true; } return false; }
template<class T> bool chmin(T &a, const T &b) { if (b < a) { a = b; return true; } return false; }
const int N = 52;
char l[N][N], r[N][N];
int dp[N][N][N][N];
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
for (int W, H; cin >> W >> H&&H;) {
memset(l, 0, sizeof(l));
memset(r, 0, sizeof(r));
memset(dp, 0x3f, sizeof(dp));
int sli, slj, sri, srj;
int gli, glj, gri, grj;
rep(i, 0, H) {
rrep(j, 0, W) {
cin >> l[i][j];
if (l[i][j] == 'L') {
sli = i, slj = j;
}
if (l[i][j] == '%') {
gli = i, glj = j;
}
}
rep(j, 0, W) {
cin >> r[i][j];
if (r[i][j] == 'R') {
sri = i, srj = j;
}
if (r[i][j] == '%') {
gri = i, grj = j;
}
}
}
using T = tuple<int, int, int, int, int>;
queue<T> q;
q.emplace(sli, slj, sri, srj, 0);
auto inrange = [&](int i, int j) { return i >= 0 && i < H && j >= 0 && j < W; };
while (q.size()) {
int li, lj, ri, rj, c;
tie(li, lj, ri, rj, c) = q.front(); q.pop();
if (dp[li][lj][ri][rj] != INF)continue;
if (li == gli && lj == glj && ri == gri && rj == grj) {
cout << "Yes" << endl;
dp[li][lj][ri][rj] = c;
break;
}
else if (li == gli&&lj == glj) {
continue;
}
else if (ri == gri&&rj == grj) {
continue;
}
dp[li][lj][ri][rj] = c;
static const int di[] = { 1,0,-1,0 };
static const int dj[] = { 0,1,0,-1 };
rep(k, 0, 4) {
int nli = li + di[k],
nlj = lj + dj[k],
nri = ri + di[k],
nrj = rj + dj[k];
if (!inrange(nli, nlj) || l[nli][nlj] == '#')nli -= di[k], nlj -= dj[k];
if (!inrange(nri, nrj) || r[nri][nrj] == '#')nri -= di[k], nrj -= dj[k];
if (dp[nli][nlj][nri][nrj] != INF)continue;
q.emplace(nli, nlj, nri, nrj, c + 1);
}
}
//rep(li, 0, H)rep(lj, 0, W)rep(ri, 0, H)rep(rj, 0, W) {
// if (dp[li][lj][ri][rj] == INF)continue;
// dump(li, lj, ri, rj, dp[li][lj][ri][rj]);
//}
if (dp[gli][glj][gri][grj] == INF) {
cout << "No" << endl;
}
}
return 0;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
One common way of digitalizing sound is to record sound intensity at particular time moments. For each time moment intensity is recorded as a non-negative integer. Thus we can represent a sound file as an array of n non-negative integers.
If there are exactly K distinct values in the array, then we need k = ⌈ log_{2} K ⌉ bits to store each value. It then takes nk bits to store the whole file.
To reduce the memory consumption we need to apply some compression. One common way is to reduce the number of possible intensity values. We choose two integers l ≤ r, and after that all intensity values are changed in the following way: if the intensity value is within the range [l;r], we don't change it. If it is less than l, we change it to l; if it is greater than r, we change it to r. You can see that we lose some low and some high intensities.
Your task is to apply this compression in such a way that the file fits onto a disk of size I bytes, and the number of changed elements in the array is minimal possible.
We remind you that 1 byte contains 8 bits.
k = ⌈ log_{2} K ⌉ is the smallest integer such that K ≤ 2^{k}. In particular, if K = 1, then k = 0.
Input
The first line contains two integers n and I (1 ≤ n ≤ 4 ⋅ 10^{5}, 1 ≤ I ≤ 10^{8}) — the length of the array and the size of the disk in bytes, respectively.
The next line contains n integers a_{i} (0 ≤ a_{i} ≤ 10^{9}) — the array denoting the sound file.
Output
Print a single integer — the minimal possible number of changed elements.
Examples
Input
6 1
2 1 2 3 4 3
Output
2
Input
6 2
2 1 2 3 4 3
Output
0
Input
6 1
1 1 2 2 3 3
Output
2
Note
In the first example we can choose l=2, r=3. The array becomes 2 2 2 3 3 3, the number of distinct elements is K=2, and the sound file fits onto the disk. Only two values are changed.
In the second example the disk is larger, so the initial file fits it and no changes are required.
In the third example we have to change both 1s or both 3s.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long n, raz, r = 0, ans = 0, dop = 0;
cin >> n >> raz;
vector<long long> a(n);
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
sort(a.begin(), a.end());
long long k = 8 * raz / n;
long long K = (k < 30 ? (1 << k) : n);
for (long long l = 0; l < n; l++) {
while (r < n) {
if (l < r && a[r] == a[r - 1])
r++;
else {
if (dop == K) break;
dop++;
r++;
}
}
ans = max(ans, r - l);
if (l < n - 1 && (l + 1 == r || a[l] != a[l + 1])) dop--;
}
cout << n - ans;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
In a far away galaxy there is war again. The treacherous Republic made k precision strikes of power ai on the Empire possessions. To cope with the republican threat, the Supreme Council decided to deal a decisive blow to the enemy forces.
To successfully complete the conflict, the confrontation balance after the blow should be a positive integer. The balance of confrontation is a number that looks like <image>, where p = n! (n is the power of the Imperial strike), <image>. After many years of war the Empire's resources are low. So to reduce the costs, n should be a minimum positive integer that is approved by the commanders.
Help the Empire, find the minimum positive integer n, where the described fraction is a positive integer.
Input
The first line contains integer k (1 ≤ k ≤ 106). The second line contains k integers a1, a2, ..., ak (1 ≤ ai ≤ 107).
Output
Print the minimum positive integer n, needed for the Empire to win.
Please, do not use the %lld to read or write 64-but integers in С++. It is preferred to use the cin, cout streams or the %I64d specificator.
Examples
Input
2
1000 1000
Output
2000
Input
1
2
Output
2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 10000010;
long long l, r;
int n, a[1000010], maxr, vis[N];
int prime[N], cnt, mindiv[N];
bool ok[N];
long long tot[N];
inline void init() {
for (int i = 2; i <= maxr; i++) {
if (!ok[i]) {
prime[++cnt] = i;
mindiv[i] = cnt;
}
for (int j = 1; j <= cnt && i * prime[j] <= maxr; j++) {
ok[i * prime[j]] = 1;
mindiv[i * prime[j]] = j;
if (i % prime[j] == 0) break;
}
}
for (int i = 1; i <= maxr; i++) {
int t = i;
while (t > 1) {
tot[mindiv[t]] += vis[i];
t /= prime[mindiv[t]];
}
}
}
inline bool check(long long x) {
for (int i = 1; i <= cnt; i++) {
long long t = 0, p = prime[i];
while (x / p) {
t += x / p;
p *= prime[i];
}
if (t < tot[i]) return false;
}
return true;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d", &a[i]), vis[a[i]]++, r += a[i], maxr = max(maxr, a[i]);
for (int i = maxr; i >= 1; i--) vis[i] += vis[i + 1];
init();
l = 1;
while (l <= r) {
long long mid = l + r >> 1;
if (check(mid))
r = mid - 1;
else
l = mid + 1;
}
printf("%I64d\n", l);
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
Let's call a positive integer n ordinary if in the decimal notation all its digits are the same. For example, 1, 2 and 99 are ordinary numbers, but 719 and 2021 are not ordinary numbers.
For a given number n, find the number of ordinary numbers among the numbers from 1 to n.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4). Then t test cases follow.
Each test case is characterized by one integer n (1 ≤ n ≤ 10^9).
Output
For each test case output the number of ordinary numbers among numbers from 1 to n.
Example
Input
6
1
2
3
4
5
100
Output
1
2
3
4
5
18
### Response
```cpp
#include<bits/stdc++.h>
#define rep(i,n) for(int i=0 ; i<n ; i++)
#define ll long long
#define pb push_back
#define mp make_pair
#define all(x) x.begin(),x.end()
using namespace std;
const ll MX=1e6+2;
const ll MOD=1e9+7;
int main(){
int t;
cin>>t;
while(t--){
ll n;
cin>>n;
ll s=floor(log10(n))+1;
vector<ll> A;
rep(i,9){
ll a=i+1,b=i+1;
rep(j,s-1){
b*=10;
b+=a;
}
A.pb(b);
}
ll ans=0;
for(auto el:A){
if(el<=n)ans++;
}
ll an=9*(s-1)+ans;
cout<<an<<endl;
}
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
The Elements of Harmony are six supernatural artifacts representing subjective aspects of harmony. They are arguably the most powerful force in Equestria. The inside of Elements of Harmony can be seen as a complete graph with n vertices labeled from 0 to n - 1, where n is a power of two, equal to 2m.
<image>
The energy in Elements of Harmony is in constant movement. According to the ancient book, the energy of vertex u in time i (ei[u]) equals to:
<image>
Here b[] is the transformation coefficient — an array of m + 1 integers and f(u, v) is the number of ones in the binary representation of number (u xor v).
Given the transformation coefficient and the energy distribution at time 0 (e0[]). Help Twilight Sparkle predict the energy distribution at time t (et[]). The answer can be quite large, so output it modulo p.
Input
The first line contains three integers m, t and p (1 ≤ m ≤ 20; 0 ≤ t ≤ 1018; 2 ≤ p ≤ 109). The following line contains n (n = 2m) integers e0[i] (1 ≤ e0[i] ≤ 109; 0 ≤ i < n). The next line contains m + 1 integers b[i] (0 ≤ b[i] ≤ 109; 0 ≤ i ≤ m).
Output
Output n lines, the i-th line must contain a single integer et[i] modulo p.
Examples
Input
2 2 10000
4 1 2 3
0 1 0
Output
14
6
6
14
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long n, m, k, p;
long long mod;
long long a[1201000], b[1201000], c[1201000];
void fwt(long long* a) {
for (int i = 0; i < m; i++)
for (int j = 0; j < n; j++)
if (!(j >> i & 1)) {
long long x = a[j], y = a[j | 1 << i];
a[j] = (x + y) % mod;
a[j | 1 << i] = (x - y + mod) % mod;
}
}
long long mul(long long x, long long y) {
long long tmp = x * y - (long long)((long double)x / mod * y + 0.5) * mod;
return tmp < 0 ? tmp + mod : tmp;
}
long long power(long long x, long long y) {
long long ret = 1;
for (; y; y >>= 1, x = mul(x, x))
if (y & 1) ret = mul(ret, x);
return ret;
}
int main() {
scanf("%lld%lld%lld", &m, &k, &p);
n = 1 << m;
mod = n * p;
for (int i = 0; i < n; i++) scanf("%lld", &a[i]), a[i] %= mod;
fwt(a);
for (int i = 0; i <= m; i++) scanf("%lld", &b[i]), b[i] %= mod;
for (int i = 0; i < n; i++) c[i] = b[__builtin_popcount(i)];
fwt(c);
for (int i = 0; i < n; i++) c[i] = mul(power(c[i] % mod, k), a[i]);
fwt(c);
for (int i = 0; i < n; i++) printf("%lld\n", c[i] / n);
return 0;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
Do you know "sed," a tool provided with Unix? Its most popular use is to substitute every occurrence of a string contained in the input string (actually each input line) with another string β. More precisely, it proceeds as follows.
1. Within the input string, every non-overlapping (but possibly adjacent) occurrences of α are marked. If there is more than one possibility for non-overlapping matching, the leftmost one is chosen.
2. Each of the marked occurrences is substituted with β to obtain the output string; other parts of the input string remain intact.
For example, when α is "aa" and β is "bca", an input string "aaxaaa" will produce "bcaxbcaa", but not "aaxbcaa" nor "bcaxabca". Further application of the same substitution to the string "bcaxbcaa" will result in "bcaxbcbca", but this is another substitution, which is counted as the second one.
In this problem, a set of substitution pairs (αi, βi) (i = 1, 2, ... , n), an initial string γ, and a final string δ are given, and you must investigate how to produce δ from γ with a minimum number of substitutions. A single substitution (αi, βi) here means simultaneously substituting all the non-overlapping occurrences of αi, in the sense described above, with βi.
You may use a specific substitution (αi, βi ) multiple times, including zero times.
Input
The input consists of multiple datasets, each in the following format.
n
α1 β1
α2 β2
.
.
.
αn βn
γ δ
n is a positive integer indicating the number of pairs. αi and βi are separated by a single space. You may assume that 1 ≤ |αi| < |βi| ≤ 10 for any i (|s| means the length of the string s), αi ≠ αj for any i ≠ j, n ≤ 10 and 1 ≤ |γ| < |δ| ≤ 10. All the strings consist solely of lowercase letters. The end of the input is indicated by a line containing a single zero.
Output
For each dataset, output the minimum number of substitutions to obtain δ from γ. If δ cannot be produced from γ with the given set of substitutions, output -1.
Example
Input
2
a bb
b aa
a
bbbbbbbb
1
a aa
a
aaaaa
3
ab aab
abc aadc
ad dee
abc
deeeeeeeec
10
a abc
b bai
c acf
d bed
e abh
f fag
g abe
h bag
i aaj
j bbb
a
abacfaabe
0
Output
3
-1
7
4
### Response
```cpp
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <functional>
#include <numeric>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <utility>
#include <sstream>
#include <complex>
#include <fstream>
#include <bitset>
#include <time.h>
#include <tuple>
#include <iomanip>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> P;
typedef vector<ll> V;
typedef complex<double> Point;
#define PI acos(-1.0)
#define EPS 1e-10
const ll INF = 1e12;
const ll MOD = 1e9 + 7;
#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define rep(i,N) for(int i=0;i<(N);i++)
#define ALL(s) (s).begin(),(s).end()
#define EQ(a,b) (abs((a)-(b))<EPS)
#define EQV(a,b) ( EQ((a).real(), (b).real()) && EQ((a).imag(), (b).imag()) )
#define fi first
#define se second
#define N_SIZE (1LL << 20)
#define NIL -1
ll sq(ll num) { return num*num; }
ll mod_pow(ll x, ll n) {
if (n == 0)return 1;
if (n == 1)return x%MOD;
ll res = sq(mod_pow(x, n / 2));
res %= MOD;
if (n % 2 == 1) {
res *= x;
res %= MOD;
}
return res;
}
ll mod_add(ll a, ll b) { return (a + b) % MOD; }
ll mod_sub(ll a, ll b) { return (a - b + MOD) % MOD; }
ll mod_mul(ll a, ll b) { return a*b % MOD; }
int n;
set<string> ss;
vector<pair<string, string>> vs;
string s, t;
ll solve(string tt, int cnt) {
//cout << tt << endl;
if (tt == t)return cnt;
if (tt.size() >= t.size() || ss.find(tt) != ss.end())return INF;
//if (cnt > 3)return INF;
ss.insert(tt);
ll res = INF;
rep(i, n) {
//cout << "!" << i << " ";
string nxt = "";
rep(j, tt.size()) {
ll num = tt.find(vs[i].first, j);
if (num != string::npos) {
nxt += tt.substr(j, num - j);
j = num + vs[i].first.size() - 1;
//cout << j << " ";
nxt += vs[i].second;
}
else nxt += tt[j];
}
//cout << endl;
res = min(res, solve(nxt, cnt + 1));
}
return res;
}
int main() {
while (cin >> n&&n) {
ss.clear();
vs.clear();
rep(i, n) {
string ss, tt;
cin >> ss >> tt;
vs.push_back({ ss,tt });
}
cin >> s >> t;
ll ans = solve(s, 0);
if (ans == INF)cout << -1 << endl;
else cout << ans << endl;
}
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
The Bitlandians are quite weird people. They do everything differently. They have a different alphabet so they have a different definition for a string.
A Bitlandish string is a string made only of characters "0" and "1".
BitHaval (the mayor of Bitland) loves to play with Bitlandish strings. He takes some Bitlandish string a, and applies several (possibly zero) operations to it. In one operation the mayor may take any two adjacent characters of a string, define one of them as x and the other one as y. Then he calculates two values p and q: p = x xor y, q = x or y. Then he replaces one of the two taken characters by p and the other one by q.
The xor operation means the bitwise excluding OR operation. The or operation is the bitwise OR operation.
So for example one operation can transform string 11 to string 10 or to string 01. String 1 cannot be transformed into any other string.
You've got two Bitlandish strings a and b. Your task is to check if it is possible for BitHaval to transform string a to string b in several (possibly zero) described operations.
Input
The first line contains Bitlandish string a, the second line contains Bitlandish string b. The strings can have different lengths.
It is guaranteed that the given strings only consist of characters "0" and "1". The strings are not empty, their length doesn't exceed 106.
Output
Print "YES" if a can be transformed into b, otherwise print "NO". Please do not print the quotes.
Examples
Input
11
10
Output
YES
Input
1
01
Output
NO
Input
000
101
Output
NO
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, ss;
cin >> s >> ss;
if (s.length() != ss.length())
cout << "NO" << endl;
else {
int flag1 = 0, flag2 = 0;
for (int i = 0; i < s.length(); i++) {
if (s[i] == '1') flag1 = 1;
if (ss[i] == '1') flag2 = 1;
}
if (flag1 == flag2)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
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 arr[100010];
int main() {
int a, b, newa, newb;
cin >> a >> b;
bool flag = true;
int ans = a;
while (true) {
newa = a;
newa = a / b;
if (newa == 0) break;
newb = a % b;
ans += newa;
a = newa + newb;
}
cout << ans;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
problem
In one programming contest, it is customary to play a bingo game at a social gathering after the competition. However, the bingo card used in this bingo game is a little special and is created according to the following conditions.
* The Bingo card is divided into squares of N rows and N columns, and one positive integer is written in each square. All those integers are different.
* The integer written in the square is 1 or more and M or less.
* The sum of N × N integers written on the Bingo card is S.
* When looking at any column, the integers are arranged in ascending order from top to bottom.
* The integer in every square is larger than any integer in the column to the left of that square.
The following is an example of a Bingo card when N = 5, M = 50, S = 685.
<image>
I want to make as many bingo cards as possible that meet the above conditions for the social gathering. However, you must not make more than one same card. Create a program that outputs the remainder of the maximum number of Bingo cards that can be created divided by 100000.
input
The input consists of multiple datasets. Each dataset is given in the following format.
The input consists of one line, which contains the size of the bingo card N (1 ≤ N ≤ 7), the upper limit of the integers written in the square M (1 ≤ M ≤ 2000), and the bingo card. Three positive integers representing the sum of integers S (1 ≤ S ≤ 3000) are written separated by blanks. However, you can make one or more bingo cards that meet the conditions for any given input data.
When N, M, S is 0, it indicates the end of input. The number of data sets does not exceed 5.
output
For each dataset, divide the maximum number of Bingo cards that can be created by 100000 and output the remainder on one line.
Examples
Input
3 9 45
3 100 50
5 50 685
0 0 0
Output
1
7
74501
Input
None
Output
None
### Response
```cpp
#include <cstdio>
#include <cstring>
using namespace std;
int n, m, s;
int dp[100][3010];
void solve(){
n *= n;
memset(dp,0,sizeof(dp));
dp[0][0] = 1;
for(int i = 1; i <= m; i++){
for(int j = n; j > 0; j--){
for(int k = i; k <= s; k++){
dp[j][k] = (dp[j][k]+dp[j-1][k-i])%100000;
}
}
}
printf("%d\n", dp[n][s]);
}
int main(){
while(scanf("%d%d%d",&n,&m,&s),n||m||s) solve();
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
Winnie-the-Pooh likes honey very much! That is why he decided to visit his friends. Winnie has got three best friends: Rabbit, Owl and Eeyore, each of them lives in his own house. There are winding paths between each pair of houses. The length of a path between Rabbit's and Owl's houses is a meters, between Rabbit's and Eeyore's house is b meters, between Owl's and Eeyore's house is c meters.
For enjoying his life and singing merry songs Winnie-the-Pooh should have a meal n times a day. Now he is in the Rabbit's house and has a meal for the first time. Each time when in the friend's house where Winnie is now the supply of honey is about to end, Winnie leaves that house. If Winnie has not had a meal the required amount of times, he comes out from the house and goes to someone else of his two friends. For this he chooses one of two adjacent paths, arrives to the house on the other end and visits his friend. You may assume that when Winnie is eating in one of his friend's house, the supply of honey in other friend's houses recover (most probably, they go to the supply store).
Winnie-the-Pooh does not like physical activity. He wants to have a meal n times, traveling minimum possible distance. Help him to find this distance.
Input
First line contains an integer n (1 ≤ n ≤ 100) — number of visits.
Second line contains an integer a (1 ≤ a ≤ 100) — distance between Rabbit's and Owl's houses.
Third line contains an integer b (1 ≤ b ≤ 100) — distance between Rabbit's and Eeyore's houses.
Fourth line contains an integer c (1 ≤ c ≤ 100) — distance between Owl's and Eeyore's houses.
Output
Output one number — minimum distance in meters Winnie must go through to have a meal n times.
Examples
Input
3
2
3
1
Output
3
Input
1
2
3
5
Output
0
Note
In the first test case the optimal path for Winnie is the following: first have a meal in Rabbit's house, then in Owl's house, then in Eeyore's house. Thus he will pass the distance 2 + 1 = 3.
In the second test case Winnie has a meal in Rabbit's house and that is for him. So he doesn't have to walk anywhere at all.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long i, n, r, S, Z, s1, s2, s3, s4, s5, s6, s7, s8, x, y, z, m, j, l, k,
t;
long long a[500005];
long long b[300045];
long long c[100001];
long long d[100001];
long long e[101][101];
pair<long long, long long> aa[100001];
double h, w, u, v, uu, vv;
string q1;
string q2;
string q3;
string q4;
string s;
string q;
string sq[50005];
string qs[3001];
map<long long, long long> g;
map<long long, long long>::iterator it;
cin >> n >> s1 >> s2 >> s3;
x = min(s1, min(s2, s3));
if (n == 1) {
cout << 0;
exit(0);
}
if (x == s1 || x == s2) {
cout << (n - 1) * x;
} else {
cout << min(s1, s2) + (n - 2) * x;
}
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
The hero of the Cut the Rope game is a little monster named Om Nom. He loves candies. And what a coincidence! He also is the hero of today's problem.
<image>
One day, Om Nom visited his friend Evan. Evan has n candies of two types (fruit drops and caramel drops), the i-th candy hangs at the height of hi centimeters above the floor of the house, its mass is mi. Om Nom wants to eat as many candies as possible. At the beginning Om Nom can make at most x centimeter high jumps. When Om Nom eats a candy of mass y, he gets stronger and the height of his jump increases by y centimeters.
What maximum number of candies can Om Nom eat if he never eats two candies of the same type in a row (Om Nom finds it too boring)?
Input
The first line contains two integers, n and x (1 ≤ n, x ≤ 2000) — the number of sweets Evan has and the initial height of Om Nom's jump.
Each of the following n lines contains three integers ti, hi, mi (0 ≤ ti ≤ 1; 1 ≤ hi, mi ≤ 2000) — the type, height and the mass of the i-th candy. If number ti equals 0, then the current candy is a caramel drop, otherwise it is a fruit drop.
Output
Print a single integer — the maximum number of candies Om Nom can eat.
Examples
Input
5 3
0 2 4
1 3 1
0 8 3
0 20 10
1 5 5
Output
4
Note
One of the possible ways to eat 4 candies is to eat them in the order: 1, 5, 3, 2. Let's assume the following scenario:
1. Initially, the height of Om Nom's jump equals 3. He can reach candies 1 and 2. Let's assume that he eats candy 1. As the mass of this candy equals 4, the height of his jump will rise to 3 + 4 = 7.
2. Now Om Nom can reach candies 2 and 5. Let's assume that he eats candy 5. Then the height of his jump will be 7 + 5 = 12.
3. At this moment, Om Nom can reach two candies, 2 and 3. He won't eat candy 2 as its type matches the type of the previously eaten candy. Om Nom eats candy 3, the height of his jump is 12 + 3 = 15.
4. Om Nom eats candy 2, the height of his jump is 15 + 1 = 16. He cannot reach candy 4.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x;
cin >> n >> x;
vector<int> h1, h2, m1, m2;
int t, h, m;
for (int i = 0; i < n; i++) {
cin >> t >> h >> m;
if (t) {
h1.push_back(h);
m1.push_back(m);
} else {
h2.push_back(h);
m2.push_back(m);
}
}
int max = 0;
int _x = x;
for (int t = 1; t <= 2; t++) {
vector<bool> e1(h1.size(), true), e2(h2.size(), true);
int turn = t;
x = _x;
int count = 0;
int p1 = 0;
int p2 = 0;
while (1) {
if (turn == 1) {
int m = 0;
int idx = -1;
for (int i = 0; i < h1.size(); i++) {
if (e1[i] && h1[i] <= x) {
if (m1[i] > m) {
idx = i;
m = m1[i];
}
}
}
if (idx != -1) {
turn = 2;
count++;
x += m1[idx];
e1[idx] = false;
} else
break;
} else {
int m = 0;
int idx = -1;
for (int i = 0; i < h2.size(); i++) {
if (e2[i] && h2[i] <= x) {
if (m2[i] > m) {
idx = i;
m = m2[i];
}
}
}
if (idx != -1) {
turn = 1;
count++;
x += m2[idx];
e2[idx] = false;
} else
break;
}
}
if (count > max) max = count;
}
cout << max;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
Snuke has a permutation (P_0,P_1,\cdots,P_{N-1}) of (0,1,\cdots,N-1).
Now, he will perform the following operation exactly once:
* Choose K consecutive elements in P and sort them in ascending order.
Find the number of permutations that can be produced as P after the operation.
Constraints
* 2 \leq N \leq 200000
* 2 \leq K \leq N
* 0 \leq P_i \leq N-1
* P_0,P_1,\cdots,P_{N-1} are all different.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N K
P_0 P_1 \cdots P_{N-1}
Output
Print the number of permutations that can be produced as P after the operation.
Examples
Input
5 3
0 2 1 4 3
Output
2
Input
4 4
0 1 2 3
Output
1
Input
10 4
2 0 1 3 7 5 4 6 8 9
Output
6
### Response
```cpp
#include <iostream>
#include <set>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
int main(){
int n, k; cin >> n >> k;
if (n==k) return puts("1") * 0e1;
int p[n]; for(int i=0; i<n; i++) cin >> p[i];
int an = 1;
set<int> s;
for(int i=0; i<k; i++) {
s.insert(p[i]);
}
for(int i=0; i<n-k; i++) {
s.insert(p[i+k]);
auto b=s.begin(), e=s.end(); e--;
//cout << *b << " " << *e << " " << p[i] << " " << p[i+k] << endl;
if (!(*b == p[i] && *e == p[i+k])) an++;
s.erase(p[i]);
}
bool nt = false; int bf=-1, ct=0;
for(int i=0; i<n; i++) {
if (bf<p[i]) ct++; else ct=1; bf=p[i];
if (ct==k) {nt=1;an--;}
}
cout << an+nt << endl;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
You can't possibly imagine how cold our friends are this winter in Nvodsk! Two of them play the following game to warm up: initially a piece of paper has an integer q. During a move a player should write any integer number that is a non-trivial divisor of the last written number. Then he should run this number of circles around the hotel. Let us remind you that a number's divisor is called non-trivial if it is different from one and from the divided number itself.
The first person who can't make a move wins as he continues to lie in his warm bed under three blankets while the other one keeps running. Determine which player wins considering that both players play optimally. If the first player wins, print any winning first move.
Input
The first line contains the only integer q (1 ≤ q ≤ 1013).
Please do not use the %lld specificator to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specificator.
Output
In the first line print the number of the winning player (1 or 2). If the first player wins then the second line should contain another integer — his first move (if the first player can't even make the first move, print 0). If there are multiple solutions, print any of them.
Examples
Input
6
Output
2
Input
30
Output
1
6
Input
1
Output
1
0
Note
Number 6 has only two non-trivial divisors: 2 and 3. It is impossible to make a move after the numbers 2 and 3 are written, so both of them are winning, thus, number 6 is the losing number. A player can make a move and write number 6 after number 30; 6, as we know, is a losing number. Thus, this move will bring us the victory.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
bool prime(long long n) {
if (n == 1) return true;
if (n == 2) return true;
if (n % 2 == 0) return false;
for (long long i = 3; i <= sqrt(n); i += 2) {
if (n % i == 0) return false;
}
return true;
}
bool flag = false;
void check(long long n, bool p) {
if (flag) return;
vector<long long> v;
for (long long i = 2; i <= sqrt(n); i++) {
if (n % i == 0) {
if (!prime(i)) v.push_back(i);
if (!prime(n / i)) v.push_back(n / i);
}
}
if (v.size() == 0 && p) {
flag = true;
cout << 1 << endl << n << endl;
return;
}
for (long long i = 0; i < v.size(); i++) check(v[i], !p);
}
int32_t main() {
long long n;
cin >> n;
if (prime(n)) {
cout << 1 << endl << 0 << endl;
return 0;
}
check(n, 0);
if (!flag) cout << 2 << endl;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
Xenia has a set of weights and pan scales. Each weight has an integer weight from 1 to 10 kilos. Xenia is going to play with scales and weights a little. For this, she puts weights on the scalepans, one by one. The first weight goes on the left scalepan, the second weight goes on the right scalepan, the third one goes on the left scalepan, the fourth one goes on the right scalepan and so on. Xenia wants to put the total of m weights on the scalepans.
Simply putting weights on the scales is not interesting, so Xenia has set some rules. First, she does not put on the scales two consecutive weights of the same weight. That is, the weight that goes i-th should be different from the (i + 1)-th weight for any i (1 ≤ i < m). Second, every time Xenia puts a weight on some scalepan, she wants this scalepan to outweigh the other one. That is, the sum of the weights on the corresponding scalepan must be strictly greater than the sum on the other pan.
You are given all types of weights available for Xenia. You can assume that the girl has an infinite number of weights of each specified type. Your task is to help Xenia lay m weights on the scales or to say that it can't be done.
Input
The first line contains a string consisting of exactly ten zeroes and ones: the i-th (i ≥ 1) character in the line equals "1" if Xenia has i kilo weights, otherwise the character equals "0". The second line contains integer m (1 ≤ m ≤ 1000).
Output
In the first line print "YES", if there is a way to put m weights on the scales by all rules. Otherwise, print in the first line "NO". If you can put m weights on the scales, then print in the next line m integers — the weights' weights in the order you put them on the scales.
If there are multiple solutions, you can print any of them.
Examples
Input
0000000101
3
Output
YES
8 10 8
Input
1000000000
2
Output
NO
### Response
```cpp
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
long long max(long long a, long long b) {
if (a > b) {
return a;
} else {
return b;
}
}
long long min(long long a, long long b) {
if (a < b) {
return a;
} else {
return b;
}
}
long long power(long long b, long long e) {
if (e == 0) return 1;
if (e % 2)
return ((b * power((b) * (b), (e - 1) / 2)));
else
return power((b) * (b), e / 2);
}
long long modpower(long long b, long long e, long long q) {
long long MOD = q;
if (e == 0) return 1;
if (e % 2)
return ((b % MOD) * modpower((b % MOD) * (b % MOD), (e - 1) / 2, q)) % MOD;
else
return modpower((b % MOD) * (b % MOD), e / 2, q) % MOD;
}
void dpv(vector<long long> v) {
for (long long i = 0; i < v.size(); i++) {
cout << v[i] << " ";
}
cout << '\n';
}
void dpv(vector<pair<long long, long long> > v) {
for (long long i = 0; i < v.size(); i++) {
cout << v[i].first << " " << v[i].second << '\n';
}
}
void dpv(set<long long> v) {
for (auto i : v) {
cout << i << " ";
}
cout << '\n';
}
bool f[11] = {0};
long long m;
vector<long long> v;
bool dfs(long long x, long long y, long long k, vector<long long> r) {
if (k == m) {
cout << "YES" << '\n';
dpv(r);
return 1;
}
bool f1 = false;
for (long long i = x + 1; i <= 10; i++) {
if (f[i] && y != i) {
r.push_back(i);
f1 = dfs(i - x, i, k + 1, r);
if (f1) {
return true;
}
r.pop_back();
}
}
return 0;
}
void oblivious() {
string s;
cin >> s;
cin >> m;
for (long long i = 1; i <= 10; i++) {
f[i] = s[i - 1] - '0';
}
vector<long long> r;
if (!dfs(0, 0, 0, r)) {
cout << "NO" << '\n';
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) {
oblivious();
}
return 0;
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
Your friend Jeff Zebos has been trying to run his new online company, but it's not going very well. He's not getting a lot of sales on his website which he decided to call Azamon. His big problem, you think, is that he's not ranking high enough on the search engines. If only he could rename his products to have better names than his competitors, then he'll be at the top of the search results and will be a millionaire.
After doing some research, you find out that search engines only sort their results lexicographically. If your friend could rename his products to lexicographically smaller strings than his competitor's, then he'll be at the top of the rankings!
To make your strategy less obvious to his competitors, you decide to swap no more than two letters of the product names.
Please help Jeff to find improved names for his products that are lexicographically smaller than his competitor's!
Given the string s representing Jeff's product name and the string c representing his competitor's product name, find a way to swap at most one pair of characters in s (that is, find two distinct indices i and j and swap s_i and s_j) such that the resulting new name becomes strictly lexicographically smaller than c, or determine that it is impossible.
Note: String a is strictly lexicographically smaller than string b if and only if one of the following holds:
* a is a proper prefix of b, that is, a is a prefix of b such that a ≠ b;
* There exists an integer 1 ≤ i ≤ min{(|a|, |b|)} such that a_i < b_i and a_j = b_j for 1 ≤ j < i.
Input
The first line of input contains a single integer t (1 ≤ t ≤ 1500) denoting the number of test cases. The next lines contain descriptions of the test cases.
Each test case consists of a single line containing two space-separated strings s and c (2 ≤ |s| ≤ 5000, 1 ≤ |c| ≤ 5000). The strings s and c consists of uppercase English letters.
It is guaranteed that the sum of |s| in the input is at most 5000 and the sum of the |c| in the input is at most 5000.
Output
For each test case, output a single line containing a single string, which is either
* the new name which is obtained after swapping no more than one pair of characters that is strictly lexicographically smaller than c. In case there are many possible such strings, you can output any of them;
* three dashes (the string "---" without quotes) if it is impossible.
Example
Input
3
AZAMON APPLE
AZAMON AAAAAAAAAAALIBABA
APPLE BANANA
Output
AMAZON
---
APPLE
Note
In the first test case, it is possible to swap the second and the fourth letters of the string and the resulting string "AMAZON" is lexicographically smaller than "APPLE".
It is impossible to improve the product's name in the second test case and satisfy all conditions.
In the third test case, it is possible not to swap a pair of characters. The name "APPLE" is lexicographically smaller than "BANANA". Note that there are other valid answers, e.g., "APPEL".
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
string s1, s2;
cin >> s1 >> s2;
long long i, j, x;
long long m = s1.size();
for (i = 0; i < m; i++) {
x = i;
for (j = m - 1; j > i; j--) {
if (s1[j] < s1[x]) {
x = j;
}
}
if (x != i) {
swap(s1[x], s1[i]);
break;
}
}
if (s1 < s2) {
cout << s1 << endl;
} else {
cout << "---" << endl;
}
}
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
You are given three integers, A, B and C.
Among them, two are the same, but the remaining one is different from the rest.
For example, when A=5,B=7,C=5, A and C are the same, but B is different.
Find the one that is different from the rest among the given three integers.
Constraints
* -100 \leq A,B,C \leq 100
* A, B and C are integers.
* The input satisfies the condition in the statement.
Input
Input is given from Standard Input in the following format:
A B C
Output
Among A, B and C, print the integer that is different from the rest.
Examples
Input
5 7 5
Output
7
Input
1 1 7
Output
7
Input
-100 100 100
Output
-100
### Response
```cpp
#include <iostream>
using namespace std;
int main() {
int a,b,c;cin>>a>>b>>c;
int ans=a;
if(a==b){
ans=c;
}else if(a==c){
ans=b;
}
cout<<ans<<endl;
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
There are n psychos standing in a line. Each psycho is assigned a unique integer from 1 to n. At each step every psycho who has an id greater than the psycho to his right (if exists) kills his right neighbor in the line. Note that a psycho might kill and get killed at the same step.
You're given the initial arrangement of the psychos in the line. Calculate how many steps are needed to the moment of time such, that nobody kills his neighbor after that moment. Look notes to understand the statement more precise.
Input
The first line of input contains integer n denoting the number of psychos, (1 ≤ n ≤ 105). In the second line there will be a list of n space separated distinct integers each in range 1 to n, inclusive — ids of the psychos in the line from left to right.
Output
Print the number of steps, so that the line remains the same afterward.
Examples
Input
10
10 9 7 8 6 5 3 4 2 1
Output
2
Input
6
1 2 3 4 5 6
Output
0
Note
In the first sample line of the psychos transforms as follows: [10 9 7 8 6 5 3 4 2 1] → [10 8 4] → [10]. So, there are two steps.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
for (auto i : v) os << i << " ";
return os;
}
template <typename T>
ostream& operator<<(ostream& os, const set<T>& v) {
for (auto i : v) os << i << " ";
return os;
}
template <typename T>
T read() {
char c = getchar();
T sgn = 1;
T t = 0;
while (!isdigit(c)) {
if (c == '-') sgn = -sgn;
c = getchar();
}
while (isdigit(c)) {
t *= 10;
t += c - '0';
c = getchar();
}
return t * sgn;
}
struct node {
int id, val;
node(int x, int y) : id(x), val(y) {}
};
const int N = 1e5 + 233;
int t[N], a[N];
stack<node> s;
int main() {
int n = read<int>();
for (int i = 0; i < n; ++i) a[i] = read<int>();
int ans = 0;
for (int i = 0; i < n; ++i) {
node temp(0, 0);
int sumn = 0;
while (!s.empty()) {
temp = s.top();
if (temp.id < a[i]) {
sumn = max(sumn, temp.val);
s.pop();
} else
break;
}
if (s.empty())
s.emplace(a[i], 0);
else
s.emplace(a[i], sumn + 1);
ans = max(s.top().val, ans);
}
printf("%d\n", ans);
return 0;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
This problem is interactive.
We have hidden an array a of n pairwise different numbers (this means that no two numbers are equal). You can get some information about this array using a new device you just ordered on Amazon.
This device can answer queries of the following form: in response to the positions of k different elements of the array, it will return the position and value of the m-th among them in the ascending order.
Unfortunately, the instruction for the device was lost during delivery. However, you remember k, but don't remember m. Your task is to find m using queries to this device.
You can ask not more than n queries.
Note that the array a and number m are fixed before the start of the interaction and don't depend on your queries. In other words, interactor is not adaptive.
Note that you don't have to minimize the number of queries, and you don't need to guess array a. You just have to guess m.
Input
The first line contains two integers n and k (1≤ k < n ≤ 500) — the length of the array and the number of the elements in the query.
It is guaranteed that number m satisfies 1≤ m ≤ k, elements a_1, a_2, ..., a_n of the array satisfy 0≤ a_i ≤ 10^9, and all of them are different.
Interaction
You begin the interaction by reading n and k.
To ask a question about elements on positions x_1, x_2, ..., x_k, in a separate line output
? x_1 x_2 x_3 ... x_k
Numbers in the query have to satisfy 1 ≤ x_i ≤ n, and all x_i have to be different. Don't forget to 'flush', to get the answer.
In response, you will receive two integers pos and a_{pos} — the position in the array a of the m-th in ascending order element among a_{x_1}, a_{x_2}, ..., a_{x_k}, and the element on this position.
In case your query is invalid or you asked more than n queries, the program will print -1 and will finish interaction. You will receive a Wrong answer verdict. Make sure to exit immediately to avoid getting other verdicts.
When you determine m, output
! m
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
For the hacks use the following format:
The first line has to contain three integers n, k, m (1 ≤ m ≤ k < n ≤ 500) — the length of the array, number of elements in the query, and which in the ascending order number the device returns.
In the next line output n integers a_1, a_2, ..., a_n (0≤ a_i ≤ 10^9) — the elements of the array. They have to be pairwise different.
Example
Input
4 3
4 9
4 9
4 9
1 2
Output
? 2 3 4
? 1 3 4
? 1 2 4
? 1 2 3
! 3
Note
In the example, n = 4, k = 3, m = 3, a = [2, 0, 1, 9].
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
map<int, int> cnt;
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= k + 1; i++) {
printf("? ");
for (int j = 1; j <= k + 1; j++)
if (j != i) printf("%d ", j);
printf("\n");
fflush(stdout);
int ind, val;
scanf("%d%d", &ind, &val);
cnt[val]++;
}
int y = (*(--cnt.end())).second;
printf("! %d", y);
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
Find the sum of the weights of edges of the Minimum-Cost Arborescence with the root r for a given weighted directed graph G = (V, E).
Constraints
* 1 ≤ |V| ≤ 100
* 0 ≤ |E| ≤ 1,000
* 0 ≤ wi ≤ 10,000
* G has arborescence(s) with the root r
Input
|V| |E| r
s0 t0 w0
s1 t1 w1
:
s|E|-1 t|E|-1 w|E|-1
, where |V| is the number of vertices and |E| is the number of edges in the graph. The graph vertices are named with the numbers 0, 1,..., |V|-1 respectively. r is the root of the Minimum-Cost Arborescence.
si and ti represent source and target verticess of i-th directed edge. wi represents the weight of the i-th directed edge.
Output
Print the sum of the weights the Minimum-Cost Arborescence.
Examples
Input
4 6 0
0 1 3
0 2 2
2 0 1
2 3 1
3 0 1
3 1 5
Output
6
Input
6 10 0
0 2 7
0 1 1
0 3 5
1 4 9
2 1 6
1 3 2
3 4 3
4 2 2
2 5 8
3 5 3
Output
11
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template< typename T, typename E = T >
struct SkewHeap {
using G = function< T(T, E) >;
using H = function< E(E, E) >;
struct Node {
T key;
E lazy;
Node *l, *r;
};
const bool rev;
const G g;
const H h;
SkewHeap(bool rev = false) : g([](const T &a, const E &b) { return a + b; }),
h([](const E &a, const E &b) { return a + b; }), rev(rev) {}
SkewHeap(const G &g, const H &h, bool rev = false) : g(g), h(h), rev(rev) {}
Node *propagate(Node *t) {
if(t->lazy != 0) {
if(t->l) t->l->lazy = h(t->l->lazy, t->lazy);
if(t->r) t->r->lazy = h(t->r->lazy, t->lazy);
t->key = g(t->key, t->lazy);
t->lazy = 0;
}
return t;
}
Node *merge(Node *x, Node *y) {
if(!x || !y) return x ? x : y;
propagate(x), propagate(y);
if((x->key > y->key) ^ rev) swap(x, y);
x->r = merge(y, x->r);
swap(x->l, x->r);
return x;
}
void push(Node *&root, const T &key) {
root = merge(root, new Node({key, 0, nullptr, nullptr}));
}
T top(Node *root) {
return propagate(root)->key;
}
void pop(Node *&root) {
propagate(root);
auto *temp = root;
root = merge(root->l, root->r);
delete temp;
}
bool empty(Node *root) const {
return !root;
}
void add(Node *root, const E &lazy) {
if(root) {
root->lazy = h(root->lazy, lazy);
propagate(root);
}
}
Node *makeheap() {
return nullptr;
}
};
struct UnionFind {
vector< int > data;
UnionFind(int sz) {
data.assign(sz, -1);
}
bool unite(int x, int y) {
x = find(x), y = find(y);
if(x == y) return (false);
if(data[x] > data[y]) swap(x, y);
data[x] += data[y];
data[y] = x;
return (true);
}
int find(int k) {
if(data[k] < 0) return (k);
return (data[k] = find(data[k]));
}
int size(int k) {
return (-data[find(k)]);
}
};
template< typename T >
struct edge {
int src, to;
T cost;
edge(int to, T cost) : src(-1), to(to), cost(cost) {}
edge(int src, int to, T cost) : src(src), to(to), cost(cost) {}
edge &operator=(const int &x) {
to = x;
return *this;
}
operator int() const { return to; }
};
template< typename T >
using Edges = vector< edge< T > >;
template< typename T >
using WeightedGraph = vector< Edges< T > >;
using UnWeightedGraph = vector< vector< int > >;
template< typename T >
using Matrix = vector< vector< T > >;
template< typename T >
struct MinimumSpanningTreeArborescence {
using Pi = pair< T, int >;
using Heap = SkewHeap< Pi, int >;
using Node = typename Heap::Node;
const Edges< T > &es;
const int V;
T INF;
MinimumSpanningTreeArborescence(const Edges< T > &es, int V) :
INF(numeric_limits< T >::max()), es(es), V(V) {}
T build(int start) {
auto g = [](const Pi &a, const T &b) { return Pi(a.first + b, a.second); };
auto h = [](const T &a, const T &b) { return a + b; };
Heap heap(g, h);
vector< Node * > heaps(V, heap.makeheap());
for(auto &e : es) heap.push(heaps[e.to], {e.cost, e.src});
UnionFind uf(V);
vector< int > used(V, -1);
used[start] = start;
T ret = 0;
for(int s = 0; s < V; s++) {
stack< int > path;
for(int u = s; used[u] < 0;) {
path.push(u);
used[u] = s;
if(heap.empty(heaps[u])) return -1;
auto p = heap.top(heaps[u]);
ret += p.first;
heap.add(heaps[u], -p.first);
heap.pop(heaps[u]);
int v = uf.find(p.second);
if(used[v] == s) {
int w;
Node *nextheap = heap.makeheap();
do {
w = path.top();
path.pop();
nextheap = heap.merge(nextheap, heaps[w]);
} while(uf.unite(v, w));
heaps[uf.find(v)] = nextheap;
used[uf.find(v)] = -1;
}
u = uf.find(v);
}
}
return ret;
}
};
int main() {
int V, E, R;
scanf("%d %d %d", &V, &E, &R);
Edges< int > edges;
for(int i = 0; i < E; i++) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
edges.emplace_back(a, b, c);
}
printf("%d\n", MinimumSpanningTreeArborescence< int >(edges, V).build(R));
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
Petya got interested in grammar on his third year in school. He invented his own language called Petya's. Petya wanted to create a maximally simple language that would be enough to chat with friends, that's why all the language's grammar can be described with the following set of rules:
* There are three parts of speech: the adjective, the noun, the verb. Each word in his language is an adjective, noun or verb.
* There are two genders: masculine and feminine. Each word in his language has gender either masculine or feminine.
* Masculine adjectives end with -lios, and feminine adjectives end with -liala.
* Masculine nouns end with -etr, and feminime nouns end with -etra.
* Masculine verbs end with -initis, and feminime verbs end with -inites.
* Thus, each word in the Petya's language has one of the six endings, given above. There are no other endings in Petya's language.
* It is accepted that the whole word consists of an ending. That is, words "lios", "liala", "etr" and so on belong to the Petya's language.
* There aren't any punctuation marks, grammatical tenses, singular/plural forms or other language complications.
* A sentence is either exactly one valid language word or exactly one statement.
Statement is any sequence of the Petya's language, that satisfy both conditions:
* Words in statement follow in the following order (from the left to the right): zero or more adjectives followed by exactly one noun followed by zero or more verbs.
* All words in the statement should have the same gender.
After Petya's friend Vasya wrote instant messenger (an instant messaging program) that supported the Petya's language, Petya wanted to add spelling and grammar checking to the program. As Vasya was in the country and Petya didn't feel like waiting, he asked you to help him with this problem. Your task is to define by a given sequence of words, whether it is true that the given text represents exactly one sentence in Petya's language.
Input
The first line contains one or more words consisting of lowercase Latin letters. The overall number of characters (including letters and spaces) does not exceed 105.
It is guaranteed that any two consecutive words are separated by exactly one space and the input data do not contain any other spaces. It is possible that given words do not belong to the Petya's language.
Output
If some word of the given text does not belong to the Petya's language or if the text contains more that one sentence, print "NO" (without the quotes). Otherwise, print "YES" (without the quotes).
Examples
Input
petr
Output
YES
Input
etis atis animatis etis atis amatis
Output
NO
Input
nataliala kataliala vetra feinites
Output
YES
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
map<string, pair<bool, int>> Data;
string msg = "";
void setData() {
Data["lios"] = {1, 1};
Data["liala"] = {0, 1};
Data["etr"] = {1, 2};
Data["etra"] = {0, 2};
Data["initis"] = {1, 3};
Data["inites"] = {0, 3};
}
pair<bool, int> find_out(string s) {
string end = "";
for (int i = (int)s.size() - 1; i >= 0 && (int)s.size() - i <= 6; --i) {
end = s[i] + end;
if ((int)s.size() - i == 3) {
if (Data.find(end) != Data.end()) return Data[end];
} else if ((int)s.size() - i == 4) {
if (Data.find(end) != Data.end()) return Data[end];
} else if ((int)s.size() - i == 5) {
if (Data.find(end) != Data.end()) return Data[end];
} else if ((int)s.size() - i == 6) {
if (Data.find(end) != Data.end()) return Data[end];
}
}
return {0, -1};
}
bool analize_grammar(vector<int> &g) {
int i;
int line = 1;
bool ord = true;
int aln = 0;
for (i = 0; i < (int)g.size() - 1; ++i) {
ord = ord & (g[i] <= g[i + 1]);
aln += (g[i] == 2);
}
aln += (g[(int)g.size() - 1] == 2);
return (aln == 1) && ord;
}
bool analize_gender(int &e, int &nw) { return ((e) ? e == nw : true); }
bool test_Word() { return find_out(msg) != pair<bool, int>(0, -1); }
bool test_Statement() {
int e_gender = 0;
int n_words = 0;
vector<int> grammar;
string s = "";
for (int i = 0; i < (int)msg.size(); ++i) {
if (msg[i] == ' ') {
++n_words;
pair<bool, int> temp = find_out(s);
if (temp == pair<bool, int>(0, -1)) return false;
s = "";
grammar.push_back(temp.second);
e_gender += temp.first;
} else {
s.push_back(msg[i]);
}
}
++n_words;
if (n_words == 1) return test_Word();
pair<bool, int> temp = find_out(s);
if (temp == pair<bool, int>(0, -1)) return false;
s = "";
grammar.push_back(temp.second);
e_gender += temp.first;
return analize_grammar(grammar) && analize_gender(e_gender, n_words);
}
int main() {
setData();
getline(cin, msg);
if (test_Statement()) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Nick's company employed n people. Now Nick needs to build a tree hierarchy of «supervisor-surbodinate» relations in the company (this is to say that each employee, except one, has exactly one supervisor). There are m applications written in the following form: «employee ai is ready to become a supervisor of employee bi at extra cost ci». The qualification qj of each employee is known, and for each application the following is true: qai > qbi.
Would you help Nick calculate the minimum cost of such a hierarchy, or find out that it is impossible to build it.
Input
The first input line contains integer n (1 ≤ n ≤ 1000) — amount of employees in the company. The following line contains n space-separated numbers qj (0 ≤ qj ≤ 106)— the employees' qualifications. The following line contains number m (0 ≤ m ≤ 10000) — amount of received applications. The following m lines contain the applications themselves, each of them in the form of three space-separated numbers: ai, bi and ci (1 ≤ ai, bi ≤ n, 0 ≤ ci ≤ 106). Different applications can be similar, i.e. they can come from one and the same employee who offered to become a supervisor of the same person but at a different cost. For each application qai > qbi.
Output
Output the only line — the minimum cost of building such a hierarchy, or -1 if it is impossible to build it.
Examples
Input
4
7 2 3 1
4
1 2 5
2 4 1
3 4 1
1 3 5
Output
11
Input
3
1 2 3
2
3 1 2
3 1 3
Output
-1
Note
In the first sample one of the possible ways for building a hierarchy is to take applications with indexes 1, 2 and 4, which give 11 as the minimum total cost. In the second sample it is impossible to build the required hierarchy, so the answer is -1.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1001;
int a[N];
int vis[N];
int n;
struct edge {
int from, to, w;
bool operator<(const edge& e) const { return w > e.w; }
};
vector<edge> adj[N];
priority_queue<edge> q;
int MST() {
int mstCost = 0;
int edges = 0;
while (!q.empty()) {
edge e = q.top();
q.pop();
if (vis[e.to]) continue;
vis[e.to] = 1;
mstCost += e.w;
++edges;
for (int j = 0; j < adj[e.to].size(); j++) {
edge ne = adj[e.to][j];
if (!vis[ne.to]) q.push(ne);
}
}
if (edges != n - 1) return -1;
return mstCost;
}
int main() {
int m;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
scanf("%d", &m);
for (int i = 0; i < m; i++) {
int u, v, w;
scanf("%d %d %d", &u, &v, &w);
--u, --v;
adj[u].push_back(edge{u, v, w});
q.push(edge{u, v, w});
}
printf("%d\n", MST());
}
``` |
### Prompt
Generate a CPP solution to the following problem:
Blake is a CEO of a large company called "Blake Technologies". He loves his company very much and he thinks that his company should be the best. That is why every candidate needs to pass through the interview that consists of the following problem.
We define function f(x, l, r) as a bitwise OR of integers xl, xl + 1, ..., xr, where xi is the i-th element of the array x. You are given two arrays a and b of length n. You need to determine the maximum value of sum f(a, l, r) + f(b, l, r) among all possible 1 ≤ l ≤ r ≤ n.
<image>
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 1000) — the length of the arrays.
The second line contains n integers ai (0 ≤ ai ≤ 109).
The third line contains n integers bi (0 ≤ bi ≤ 109).
Output
Print a single integer — the maximum value of sum f(a, l, r) + f(b, l, r) among all possible 1 ≤ l ≤ r ≤ n.
Examples
Input
5
1 2 4 3 2
2 3 3 12 1
Output
22
Input
10
13 2 7 11 8 4 9 8 5 1
5 7 18 9 2 3 0 11 8 6
Output
46
Note
Bitwise OR of two non-negative integers a and b is the number c = a OR b, such that each of its digits in binary notation is 1 if and only if at least one of a or b have 1 in the corresponding position in binary notation.
In the first sample, one of the optimal answers is l = 2 and r = 4, because f(a, 2, 4) + f(b, 2, 4) = (2 OR 4 OR 3) + (3 OR 3 OR 12) = 7 + 15 = 22. Other ways to get maximum value is to choose l = 1 and r = 4, l = 1 and r = 5, l = 2 and r = 4, l = 2 and r = 5, l = 3 and r = 4, or l = 3 and r = 5.
In the second sample, the maximum value is obtained for l = 1 and r = 9.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int a[1001], b[1001];
map<pair<int, int>, int> mapp;
int main(void) {
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
for (int i = 0; i < n; ++i) {
cin >> b[i];
}
for (int i = 0; i < n; ++i) {
int xorr = 0;
for (int j = i; j < n; ++j) {
xorr |= a[j];
mapp[make_pair(i, j)] = xorr;
}
}
int ans = 0;
for (int i = 0; i < n; ++i) {
int xorr = 0;
for (int j = i; j < n; ++j) {
xorr |= b[j];
if (xorr + mapp[make_pair(i, j)] > ans) {
ans = xorr + mapp[make_pair(i, j)];
}
}
}
cout << ans;
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
You are given an undirected graph consisting of N vertices and M edges. The vertices are numbered 1 to N, and the edges are numbered 1 to M. In addition, each vertex has a label, `A` or `B`. The label of Vertex i is s_i. Edge i bidirectionally connects vertex a_i and b_i.
The phantom thief Nusook likes to choose some vertex as the startpoint and traverse an edge zero or more times. Today, he will make a string after traveling as above, by placing the labels of the visited vertices in the order visited, beginning from the startpoint.
For example, in a graph where Vertex 1 has the label `A` and Vertex 2 has the label `B`, if Nusook travels along the path 1 \rightarrow 2 \rightarrow 1 \rightarrow 2 \rightarrow 2, the resulting string is `ABABB`.
Determine if Nusook can make all strings consisting of `A` and `B`.
Constraints
* 2 \leq N \leq 2 \times 10^{5}
* 1 \leq M \leq 2 \times 10^{5}
* |s| = N
* s_i is `A` or `B`.
* 1 \leq a_i, b_i \leq N
* The given graph may NOT be simple or connected.
Input
Input is given from Standard Input in the following format:
N M
s
a_1 b_1
:
a_{M} b_{M}
Output
If Nusook can make all strings consisting of `A` and `B`, print `Yes`; otherwise, print `No`.
Examples
Input
2 3
AB
1 1
1 2
2 2
Output
Yes
Input
4 3
ABAB
1 2
2 3
3 1
Output
No
Input
13 23
ABAAAABBBBAAB
7 1
10 6
1 11
2 10
2 8
2 11
11 12
8 3
7 12
11 2
13 13
11 9
4 1
9 7
9 6
8 13
8 6
4 10
8 7
4 3
2 1
8 12
6 9
Output
Yes
Input
13 17
BBABBBAABABBA
7 1
7 9
11 12
3 9
11 9
2 1
11 5
12 11
10 8
1 11
1 8
7 7
9 10
8 8
8 12
6 2
13 11
Output
No
### Response
```cpp
#include<bits/stdc++.h>
#define LL long long
using namespace std;
const int N=2e5+10;
int rd()
{
int x=0,w=1;char ch=0;
while(ch<'0'||ch>'9'){if(ch=='-') w=-1;ch=getchar();}
while(ch>='0'&&ch<='9'){x=x*10+(ch^48);ch=getchar();}
return x*w;
}
int to[N<<1],nt[N<<1],hd[N],dg[N][2],tot=1;
void adde(int x,int y)
{
++tot,to[tot]=y,nt[tot]=hd[x],hd[x]=tot;
++tot,to[tot]=x,nt[tot]=hd[y],hd[y]=tot;
}
char cc[N];
int n,m,tt;
bool v[N];
int main()
{
n=rd(),m=rd();
scanf("%s",cc+1);
for(int i=1;i<=m;++i)
{
int x=rd(),y=rd();
adde(x,y);
++dg[x][cc[y]-'A'],++dg[y][cc[x]-'A'];
}
queue<int> q;
for(int i=1;i<=n;++i)
if(!dg[i][0]||!dg[i][1]) v[i]=1,q.push(i);
while(!q.empty())
{
int x=q.front();
q.pop();
++tt;
for(int i=hd[x];i;i=nt[i])
{
int y=to[i];
--dg[y][cc[x]-'A'];
if(!v[y]&&!dg[y][cc[x]-'A']) v[y]=1,q.push(y);
}
}
puts(tt==n?"No":"Yes");
return 0;
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
You are given a weighted tree (undirected connected graph with no cycles, loops or multiple edges) with n vertices. The edge \\{u_j, v_j\} has weight w_j. Also each vertex i has its own value a_i assigned to it.
Let's call a path starting in vertex u and ending in vertex v, where each edge can appear no more than twice (regardless of direction), a 2-path. Vertices can appear in the 2-path multiple times (even start and end vertices).
For some 2-path p profit Pr(p) = ∑_{v ∈ distinct vertices in p}{a_v} - ∑_{e ∈ distinct edges in p}{k_e ⋅ w_e}, where k_e is the number of times edge e appears in p. That is, vertices are counted once, but edges are counted the number of times they appear in p.
You are about to answer m queries. Each query is a pair of vertices (qu, qv). For each query find 2-path p from qu to qv with maximal profit Pr(p).
Input
The first line contains two integers n and q (2 ≤ n ≤ 3 ⋅ 10^5, 1 ≤ q ≤ 4 ⋅ 10^5) — the number of vertices in the tree and the number of queries.
The second line contains n space-separated integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — the values of the vertices.
Next n - 1 lines contain descriptions of edges: each line contains three space separated integers u_i, v_i and w_i (1 ≤ u_i, v_i ≤ n, u_i ≠ v_i, 1 ≤ w_i ≤ 10^9) — there is edge \\{u_i, v_i\} with weight w_i in the tree.
Next q lines contain queries (one per line). Each query contains two integers qu_i and qv_i (1 ≤ qu_i, qv_i ≤ n) — endpoints of the 2-path you need to find.
Output
For each query print one integer per line — maximal profit Pr(p) of the some 2-path p with the corresponding endpoints.
Example
Input
7 6
6 5 5 3 2 1 2
1 2 2
2 3 2
2 4 1
4 5 1
6 4 2
7 3 25
1 1
4 4
5 6
6 4
3 4
3 7
Output
9
9
9
8
12
-14
Note
Explanation of queries:
1. (1, 1) — one of the optimal 2-paths is the following: 1 → 2 → 4 → 5 → 4 → 2 → 3 → 2 → 1. Pr(p) = (a_1 + a_2 + a_3 + a_4 + a_5) - (2 ⋅ w(1,2) + 2 ⋅ w(2,3) + 2 ⋅ w(2,4) + 2 ⋅ w(4,5)) = 21 - 2 ⋅ 12 = 9.
2. (4, 4): 4 → 2 → 1 → 2 → 3 → 2 → 4. Pr(p) = (a_1 + a_2 + a_3 + a_4) - 2 ⋅ (w(1,2) + w(2,3) + w(2,4)) = 19 - 2 ⋅ 10 = 9.
3. (5, 6): 5 → 4 → 2 → 3 → 2 → 1 → 2 → 4 → 6.
4. (6, 4): 6 → 4 → 2 → 1 → 2 → 3 → 2 → 4.
5. (3, 4): 3 → 2 → 1 → 2 → 4.
6. (3, 7): 3 → 2 → 1 → 2 → 4 → 5 → 4 → 2 → 3 → 7.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long N, Q;
map<long long, long long> adj[300000 + 1];
long long depth[300000 + 1];
long long dp[300000 + 1];
long long dp2[300000 + 1];
long long up[300000 + 1][20 + 1];
long long edgeSum[300000 + 1][20 + 1];
long long dpSum[300000 + 1][20 + 1];
long long f(long long u, long long v) {
return max(dp2[v] - 2 * adj[u][v], 0LL);
}
void dfs1(long long node, long long par) {
for (auto i : adj[node])
if (i.first != par) {
dfs1(i.first, node);
dp2[node] += f(node, i.first);
}
}
void dfs2(long long node, long long par) {
dp[node] = dp2[node];
for (auto i : adj[node]) {
if (i.first == par) continue;
dp2[node] -= f(node, i.first);
dp2[i.first] += f(i.first, node);
dfs2(i.first, node);
dp2[i.first] -= f(i.first, node);
dp2[node] += f(node, i.first);
}
}
void dfs3(long long node, long long par) {
depth[node] = depth[up[node][0] = par] + 1;
dpSum[node][0] = dp2[node] - f(par, node);
for (long long i = 1; i <= 20; i++) {
dpSum[node][i] = dpSum[node][i - 1] + dpSum[up[node][i - 1]][i - 1];
edgeSum[node][i] = edgeSum[node][i - 1] + edgeSum[up[node][i - 1]][i - 1];
up[node][i] = up[up[node][i - 1]][i - 1];
}
for (auto i : adj[node])
if (i.first != par) {
edgeSum[i.first][0] = i.second;
dfs3(i.first, node);
}
}
pair<long long, long long> jmp(long long x, long long k) {
long long ret = 0;
for (long long i = 0; i <= 20; i++)
if ((k >> i) & 1) {
ret += dpSum[x][i];
ret -= edgeSum[x][i];
x = up[x][i];
}
return {x ? x : -1, ret};
}
long long query(long long a, long long b) {
if (depth[a] < depth[b]) swap(a, b);
long long ret = 0;
pair<long long, long long> ans = jmp(a, depth[a] - depth[b]);
a = ans.first, ret = ans.second;
assert(a != -1);
if (a == b) return ret + dp[a];
for (long long i = 20; i >= 0; i--) {
long long newA = up[a][i], newB = up[b][i];
if (newA != newB) {
ret += dpSum[a][i] + dpSum[b][i];
ret -= edgeSum[a][i] + edgeSum[b][i];
a = newA, b = newB;
}
}
return ret + dpSum[a][0] + dpSum[b][0] - edgeSum[a][0] - edgeSum[b][0] +
dp[up[a][0]];
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> N >> Q;
for (long long i = 1; i <= N; i++) cin >> dp2[i];
for (long long i = 1; i < N; i++) {
long long u, v, c;
cin >> u >> v >> c;
adj[u][v] = c;
adj[v][u] = c;
}
dfs1(1, 0);
dfs2(1, 0);
dfs3(1, 0);
for (long long i = 1; i <= Q; i++) {
long long a, b;
cin >> a >> b;
cout << query(a, b) << "\n";
}
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
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 ≤ 10, 1 ≤ k ≤ n) — 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;
int r, c, n, k, dp[105][105];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> r >> c >> n >> k;
int x, y;
int ans = 0;
for (int i = 1; i <= n; i++) {
cin >> x >> y;
dp[x][y]++;
}
for (int x1 = 1; x1 <= r; x1++)
for (int fasdfasd = 1; fasdfasd <= c; fasdfasd++)
for (int x2 = x1; x2 <= r; x2++)
for (int y2 = fasdfasd; y2 <= c; y2++) {
int cur = 0;
for (int i = x1; i <= x2; i++)
for (int j = fasdfasd; j <= y2; j++)
if (dp[i][j]) cur++;
if (cur >= k) ans++;
}
cout << ans << '\n';
cout.flush();
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
Yeah, we failed to make up a New Year legend for this problem.
A permutation of length n is an array of n integers such that every integer from 1 to n appears in it exactly once.
An element y of permutation p is reachable from element x if x = y, or p_x = y, or p_{p_x} = y, and so on.
The decomposition of a permutation p is defined as follows: firstly, we have a permutation p, all elements of which are not marked, and an empty list l. Then we do the following: while there is at least one not marked element in p, we find the leftmost such element, list all elements that are reachable from it in the order they appear in p, mark all of these elements, then cyclically shift the list of those elements so that the maximum appears at the first position, and add this list as an element of l. After all elements are marked, l is the result of this decomposition.
For example, if we want to build a decomposition of p = [5, 4, 2, 3, 1, 7, 8, 6], we do the following:
1. initially p = [5, 4, 2, 3, 1, 7, 8, 6] (bold elements are marked), l = [];
2. the leftmost unmarked element is 5; 5 and 1 are reachable from it, so the list we want to shift is [5, 1]; there is no need to shift it, since maximum is already the first element;
3. p = [5, 4, 2, 3, 1, 7, 8, 6], l = [[5, 1]];
4. the leftmost unmarked element is 4, the list of reachable elements is [4, 2, 3]; the maximum is already the first element, so there's no need to shift it;
5. p = [5, 4, 2, 3, 1, 7, 8, 6], l = [[5, 1], [4, 2, 3]];
6. the leftmost unmarked element is 7, the list of reachable elements is [7, 8, 6]; we have to shift it, so it becomes [8, 6, 7];
7. p = [5, 4, 2, 3, 1, 7, 8, 6], l = [[5, 1], [4, 2, 3], [8, 6, 7]];
8. all elements are marked, so [[5, 1], [4, 2, 3], [8, 6, 7]] is the result.
The New Year transformation of a permutation is defined as follows: we build the decomposition of this permutation; then we sort all lists in decomposition in ascending order of the first elements (we don't swap the elements in these lists, only the lists themselves); then we concatenate the lists into one list which becomes a new permutation. For example, the New Year transformation of p = [5, 4, 2, 3, 1, 7, 8, 6] is built as follows:
1. the decomposition is [[5, 1], [4, 2, 3], [8, 6, 7]];
2. after sorting the decomposition, it becomes [[4, 2, 3], [5, 1], [8, 6, 7]];
3. [4, 2, 3, 5, 1, 8, 6, 7] is the result of the transformation.
We call a permutation good if the result of its transformation is the same as the permutation itself. For example, [4, 3, 1, 2, 8, 5, 6, 7] is a good permutation; and [5, 4, 2, 3, 1, 7, 8, 6] is bad, since the result of transformation is [4, 2, 3, 5, 1, 8, 6, 7].
Your task is the following: given n and k, find the k-th (lexicographically) good permutation of length n.
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases.
Then the test cases follow. Each test case is represented by one line containing two integers n and k (1 ≤ n ≤ 50, 1 ≤ k ≤ 10^{18}).
Output
For each test case, print the answer to it as follows: if the number of good permutations of length n is less than k, print one integer -1; otherwise, print the k-th good permutation on n elements (in lexicographical order).
Example
Input
5
3 3
5 15
4 13
6 8
4 2
Output
2 1 3
3 1 2 5 4
-1
1 2 6 3 4 5
1 2 4 3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int mxN = 50;
const long long oo = 1ll << 60;
int n;
long long k, dp[mxN + 1], f[mxN + 1], g[mxN + 1];
bool b1[mxN];
long long add(long long a, long long b) {
if (a + b <= oo) return a + b;
return oo;
}
long long mult(long long a, long long b) {
if (a <= oo / b) return a * b;
return oo;
}
vector<int> rec2(int n, long long k) {
vector<int> p(n);
p[0] = n - 1;
memset(b1, 0, n);
b1[n - 1] = 1;
for (int i = 1; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (b1[j]) continue;
p[i] = j;
long long c;
if (i < n - 1) {
c = f[n - 2 - i];
int b = j;
while (b <= i) {
if (b == i) break;
b = p[b];
}
if (b == i) c = 0;
} else
c = 1;
if (c <= k) {
k -= c;
} else {
b1[j] = 1;
break;
}
}
}
return p;
}
vector<int> rec1(int n, long long k) {
if (!n) return vector<int>();
for (int i = 1; i <= n; ++i) {
if (mult(dp[n - i], g[i]) <= k) {
k -= mult(dp[n - i], g[i]);
} else {
vector<int> w1 = rec2(i, k / dp[n - i]), w2 = rec1(n - i, k % dp[n - i]);
for (int &wi : w2) wi += i;
w1.insert(w1.end(), w2.begin(), w2.end());
return w1;
}
}
}
void solve() {
cin >> n >> k;
if (dp[n] < k) {
cout << "-1\n";
return;
}
vector<int> v = rec1(n, k - 1);
for (int i = 0; i < n; ++i) cout << v[i] + 1 << " ";
cout << "\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
f[0] = 1;
for (int i = 1; i <= mxN; ++i) f[i] = mult(f[i - 1], i);
g[1] = 1;
for (int i = 2; i <= mxN; ++i) g[i] = f[i - 2];
dp[0] = 1;
for (int i = 1; i <= mxN; ++i) {
for (int j = 1; j <= i; ++j) dp[i] = add(dp[i], mult(dp[i - j], g[j]));
}
int t;
cin >> t;
while (t--) solve();
}
``` |
### Prompt
Create a solution in cpp for the following problem:
There is a grid of square cells with H horizontal rows and W vertical columns. The cell at the i-th row and the j-th column will be denoted as Cell (i, j).
In Cell (i, j), a_{ij} coins are placed.
You can perform the following operation any number of times:
Operation: Choose a cell that was not chosen before and contains one or more coins, then move one of those coins to a vertically or horizontally adjacent cell.
Maximize the number of cells containing an even number of coins.
Constraints
* All values in input are integers.
* 1 \leq H, W \leq 500
* 0 \leq a_{ij} \leq 9
Input
Input is given from Standard Input in the following format:
H W
a_{11} a_{12} ... a_{1W}
a_{21} a_{22} ... a_{2W}
:
a_{H1} a_{H2} ... a_{HW}
Output
Print a sequence of operations that maximizes the number of cells containing an even number of coins, in the following format:
N
y_1 x_1 y_1' x_1'
y_2 x_2 y_2' x_2'
:
y_N x_N y_N' x_N'
That is, in the first line, print an integer N between 0 and H \times W (inclusive), representing the number of operations.
In the (i+1)-th line (1 \leq i \leq N), print four integers y_i, x_i, y_i' and x_i' (1 \leq y_i, y_i' \leq H and 1 \leq x_i, x_i' \leq W), representing the i-th operation. These four integers represents the operation of moving one of the coins placed in Cell (y_i, x_i) to a vertically or horizontally adjacent cell, (y_i', x_i').
Note that if the specified operation violates the specification in the problem statement or the output format is invalid, it will result in Wrong Answer.
Examples
Input
2 3
1 2 3
0 1 1
Output
3
2 2 2 3
1 1 1 2
1 3 1 2
Input
3 2
1 0
2 1
1 0
Output
3
1 1 1 2
1 2 2 2
3 1 3 2
Input
1 5
9 9 9 9 9
Output
2
1 1 1 2
1 3 1 4
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(){
int H,W;
cin >> H >> W;
vector<int> w(H*W),m(2*H*W);
int i,j,k=0;
for(i=0; i<H*W; i++){
cin >> w.at(i);
}
for(i=0; i<H; i++){
for(j=0; j<W-1; j++){
if(w.at(i*W+j)%2 == 1){
w.at(i*W+j)-=1;
w.at(i*W+j+1)+=1;
m.at(2*k)=i*W+j;
m.at(2*k+1)=i*W+j+1;
k++;
}
}
}
for(i=0; i<H-1; i++){
if(w.at((i+1)*W-1)%2 == 1){
w.at((i+1)*W-1)-=1;
w.at((i+2)*W-1)+=1;
m.at(2*k)=(i+1)*W-1;
m.at(2*k+1)=(i+2)*W-1;
k++;
}
}
cout << k << endl;
for(i=0; i<k; i++){
cout << m.at(2*i)/W+1 << " " << m.at(2*i)%W+1 << " " << m.at(2*i+1)/W+1 << " " << m.at(2*i+1)%W+1 << endl;
}
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
Karen has just arrived at school, and she has a math test today!
<image>
The test is about basic addition and subtraction. Unfortunately, the teachers were too busy writing tasks for Codeforces rounds, and had no time to make an actual test. So, they just put one question in the test that is worth all the points.
There are n integers written on a row. Karen must alternately add and subtract each pair of adjacent integers, and write down the sums or differences on the next row. She must repeat this process on the values on the next row, and so on, until only one integer remains. The first operation should be addition.
Note that, if she ended the previous row by adding the integers, she should start the next row by subtracting, and vice versa.
The teachers will simply look at the last integer, and then if it is correct, Karen gets a perfect score, otherwise, she gets a zero for the test.
Karen has studied well for this test, but she is scared that she might make a mistake somewhere and it will cause her final answer to be wrong. If the process is followed, what number can she expect to be written on the last row?
Since this number can be quite large, output only the non-negative remainder after dividing it by 109 + 7.
Input
The first line of input contains a single integer n (1 ≤ n ≤ 200000), the number of numbers written on the first row.
The next line contains n integers. Specifically, the i-th one among these is ai (1 ≤ ai ≤ 109), the i-th number on the first row.
Output
Output a single integer on a line by itself, the number on the final row after performing the process above.
Since this number can be quite large, print only the non-negative remainder after dividing it by 109 + 7.
Examples
Input
5
3 6 9 12 15
Output
36
Input
4
3 7 5 2
Output
1000000006
Note
In the first test case, the numbers written on the first row are 3, 6, 9, 12 and 15.
Karen performs the operations as follows:
<image>
The non-negative remainder after dividing the final number by 109 + 7 is still 36, so this is the correct output.
In the second test case, the numbers written on the first row are 3, 7, 5 and 2.
Karen performs the operations as follows:
<image>
The non-negative remainder after dividing the final number by 109 + 7 is 109 + 6, so this is the correct output.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void get(int &v) {
char c;
while ((c = getchar()) != EOF && isdigit(c) == 0)
;
v = c - '0';
while ((c = getchar()) != EOF && isdigit(c))
v = (v << 3) + (v << 1) + c - '0';
return;
}
int pow_mod(long long a, int x) {
int ans = 1;
while (x) {
if (x & 1) ans = ans * a % 1000000007;
a = a * a % 1000000007;
x >>= 1;
}
return ans;
}
int a[200000 + 80];
int main() {
int n, i, ans = 0;
long long f = 1, tmp;
get(n);
for (i = 1; i <= n; i++) get(a[i]);
switch (n % 4) {
case 0:
for (i = 1; i <= (n >> 1); i++) {
ans = (ans + (a[(i << 1) - 1] - a[(i << 1)]) * f) % 1000000007;
f = f * ((n >> 1) - i) % 1000000007 * pow_mod(i, 1000000007 - 2) %
1000000007;
}
break;
case 1:
for (i = 0; i <= (n >> 1); i++) {
ans = (ans + a[(i << 1) + 1] * f) % 1000000007;
f = f * ((n >> 1) - i) % 1000000007 * pow_mod(i + 1, 1000000007 - 2) %
1000000007;
}
break;
case 2:
for (i = 1; i <= (n >> 1); i++) {
ans = (ans + (a[(i << 1) - 1] + a[(i << 1)]) * f) % 1000000007;
f = f * ((n >> 1) - i) % 1000000007 * pow_mod(i, 1000000007 - 2) %
1000000007;
}
break;
case 3:
ans = a[1];
for (i = 1; i <= (n >> 1); i++) {
ans = (ans + ((a[i << 1] * f) << 1)) % 1000000007;
tmp = f;
f = f * ((n >> 1) - i) % 1000000007 * pow_mod(i, 1000000007 - 2) %
1000000007;
ans = (ans + (f - tmp) * a[(i << 1) + 1]) % 1000000007;
}
break;
}
printf("%d", (ans + 1000000007) % 1000000007);
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
Mikhail walks on a 2D plane. He can go either up or right. You are given a sequence of Mikhail's moves. He thinks that this sequence is too long and he wants to make it as short as possible.
In the given sequence moving up is described by character U and moving right is described by character R. Mikhail can replace any pair of consecutive moves RU or UR with a diagonal move (described as character D). After that, he can go on and do some other replacements, until there is no pair of consecutive moves RU or UR left.
Your problem is to print the minimum possible length of the sequence of moves after the replacements.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 100) — the length of the sequence. The second line contains the sequence consisting of n characters U and R.
Output
Print the minimum possible length of the sequence of moves after all replacements are done.
Examples
Input
5
RUURU
Output
3
Input
17
UUURRRRRUUURURUUU
Output
13
Note
In the first test the shortened sequence of moves may be DUD (its length is 3).
In the second test the shortened sequence of moves can be UUDRRRDUDDUUU (its length is 13).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
const int MAXN = 1000100;
char s[110];
int main() {
int n;
cin >> n;
char c;
int r = 0, u = 0;
for (int i = 0; i < n; ++i) {
cin >> s[i];
}
int ans = n;
for (int i = 0; i < n; ++i) {
if (s[i] == 'U' && s[i + 1] == 'R' || s[i] == 'R' && s[i + 1] == 'U') {
--ans;
i++;
}
}
cout << ans << endl;
return 0;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
Natasha is going to fly to Mars. She needs to build a rocket, which consists of several stages in some order. Each of the stages is defined by a lowercase Latin letter. This way, the rocket can be described by the string — concatenation of letters, which correspond to the stages.
There are n stages available. The rocket must contain exactly k of them. Stages in the rocket should be ordered by their weight. So, after the stage with some letter can go only stage with a letter, which is at least two positions after in the alphabet (skipping one letter in between, or even more). For example, after letter 'c' can't go letters 'a', 'b', 'c' and 'd', but can go letters 'e', 'f', ..., 'z'.
For the rocket to fly as far as possible, its weight should be minimal. The weight of the rocket is equal to the sum of the weights of its stages. The weight of the stage is the number of its letter in the alphabet. For example, the stage 'a 'weighs one ton,' b 'weighs two tons, and' z' — 26 tons.
Build the rocket with the minimal weight or determine, that it is impossible to build a rocket at all. Each stage can be used at most once.
Input
The first line of input contains two integers — n and k (1 ≤ k ≤ n ≤ 50) – the number of available stages and the number of stages to use in the rocket.
The second line contains string s, which consists of exactly n lowercase Latin letters. Each letter defines a new stage, which can be used to build the rocket. Each stage can be used at most once.
Output
Print a single integer — the minimal total weight of the rocket or -1, if it is impossible to build the rocket at all.
Examples
Input
5 3
xyabd
Output
29
Input
7 4
problem
Output
34
Input
2 2
ab
Output
-1
Input
12 1
abaabbaaabbb
Output
1
Note
In the first example, the following rockets satisfy the condition:
* "adx" (weight is 1+4+24=29);
* "ady" (weight is 1+4+25=30);
* "bdx" (weight is 2+4+24=30);
* "bdy" (weight is 2+4+25=31).
Rocket "adx" has the minimal weight, so the answer is 29.
In the second example, target rocket is "belo". Its weight is 2+5+12+15=34.
In the third example, n=k=2, so the rocket must have both stages: 'a' and 'b'. This rocket doesn't satisfy the condition, because these letters are adjacent in the alphabet. Answer is -1.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using ll = long long int;
int main() {
int n, k;
cin >> n >> k;
set<char> st;
string s;
cin >> s;
for (int i = 0; i < n; ++i) st.insert(s[i]);
int res = 0;
char lastc = 0;
int i;
for (i = 0; i < k && !st.empty(); ++i) {
auto it = st.begin();
char c = *it;
st.erase(it);
if (*it - lastc < 2)
--i;
else {
res += int(c - 'a' + 1);
lastc = c;
}
}
if (i == k)
cout << res << "\n";
else
cout << -1 << "\n";
return 0;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
Alex doesn't like boredom. That's why whenever he gets bored, he comes up with games. One long winter evening he came up with a game and decided to play it.
Given a sequence a consisting of n integers. The player can make several steps. In a single step he can choose an element of the sequence (let's denote it ak) and delete it, at that all elements equal to ak + 1 and ak - 1 also must be deleted from the sequence. That step brings ak points to the player.
Alex is a perfectionist, so he decided to get as many points as possible. Help him.
Input
The first line contains integer n (1 ≤ n ≤ 105) that shows how many numbers are in Alex's sequence.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 105).
Output
Print a single integer — the maximum number of points that Alex can earn.
Examples
Input
2
1 2
Output
2
Input
3
1 2 3
Output
4
Input
9
1 2 1 3 2 2 2 2 3
Output
10
Note
Consider the third test example. At first step we need to choose any element equal to 2. After that step our sequence looks like this [2, 2, 2, 2]. Then we do 4 steps, on each step we choose any element equals to 2. In total we earn 10 points.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n;
long long tbl[100002];
int num[100002];
int cnt[100002];
long long t, acc;
long long dyn(int x) {
if (x < 1) return 0;
long long &r = tbl[x];
if (r == -1) {
if (num[x - 1]) {
long long r1 = (x - 1) * cnt[x - 1] + dyn(x - 2);
long long r2 = x * cnt[x] + (x - 2) * cnt[x - 2] + dyn(x - 3);
r = r1 < r2 ? r1 : r2;
} else {
r = dyn(x - 1);
}
}
return r;
}
int main() {
memset(tbl, -1, sizeof tbl);
memset(num, 0, sizeof num);
memset(cnt, 0, sizeof cnt);
t = 0;
cin >> n;
int mx = -1;
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
num[x] = 1;
++cnt[x];
t += x;
if (x > mx) {
mx = x;
}
}
cout << t - dyn(mx) << endl;
return 0;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
You are solving the crossword problem K from IPSC 2014. You solved all the clues except for one: who does Eevee evolve into? You are not very into pokemons, but quick googling helped you find out, that Eevee can evolve into eight different pokemons: Vaporeon, Jolteon, Flareon, Espeon, Umbreon, Leafeon, Glaceon, and Sylveon.
You know the length of the word in the crossword, and you already know some letters. Designers of the crossword made sure that the answer is unambiguous, so you can assume that exactly one pokemon out of the 8 that Eevee evolves into fits the length and the letters given. Your task is to find it.
Input
First line contains an integer n (6 ≤ n ≤ 8) – the length of the string.
Next line contains a string consisting of n characters, each of which is either a lower case english letter (indicating a known letter) or a dot character (indicating an empty cell in the crossword).
Output
Print a name of the pokemon that Eevee can evolve into that matches the pattern in the input. Use lower case letters only to print the name (in particular, do not capitalize the first letter).
Examples
Input
7
j......
Output
jolteon
Input
7
...feon
Output
leafeon
Input
7
.l.r.o.
Output
flareon
Note
Here's a set of names in a form you can paste into your solution:
["vaporeon", "jolteon", "flareon", "espeon", "umbreon", "leafeon", "glaceon", "sylveon"]
{"vaporeon", "jolteon", "flareon", "espeon", "umbreon", "leafeon", "glaceon", "sylveon"}
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
template <typename T>
void alert(const T& t) {
cout << t << endl;
exit(0);
}
const int N = 1e9 + 7;
int main() {
{}
int n;
cin >> n;
vector<string> mas = {"vaporeon", "jolteon", "flareon", "espeon",
"umbreon", "leafeon", "glaceon", "sylveon"};
string str;
cin >> str;
for (int j = 0; j < mas.size(); ++j) {
bool flagYhy = 1;
if (mas[j].size() != str.size()) continue;
for (int i = 0; i < str.size(); ++i) {
if (str[i] == '.') continue;
if (str[i] != mas[j][i]) {
flagYhy = 0;
break;
}
}
if (flagYhy) {
cout << mas[j] << endl;
}
}
return 0;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
Create a program that outputs all leap years between the year a and year b.
The leap year conditions are as follows. However, 0 <a ≤ b <3,000. If there is no leap year in the given period, output "NA".
* The year is divisible by 4.
* However, a year divisible by 100 is not a leap year.
* However, a year divisible by 400 is a leap year.
Input
Given multiple datasets. The format of each dataset is as follows:
a b
Input ends when both a and b are 0. The number of datasets does not exceed 50.
Output
Print the year or NA for each dataset.
Insert one blank line between the datasets.
Example
Input
2001 2010
2005 2005
2001 2010
0 0
Output
2004
2008
NA
2004
2008
### Response
```cpp
#include "bits/stdc++.h"
using namespace std;
int a,b;
int init=0;
int main(){
while(cin>>a>>b){
if(a==0&&b==0)break;
if(init!=0)cout<<endl;
init=1;
int ans=0;
for (int i = a; i <= b; ++i) {
if((i%4==0)&&(i%100)!=0||(i%400==0)){cout<<i<<endl;ans++;}
}
if(ans==0){cout<<"NA"<<endl;}
}
return 0;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
Leha is planning his journey from Moscow to Saratov. He hates trains, so he has decided to get from one city to another by car.
The path from Moscow to Saratov can be represented as a straight line (well, it's not that straight in reality, but in this problem we will consider it to be straight), and the distance between Moscow and Saratov is n km. Let's say that Moscow is situated at the point with coordinate 0 km, and Saratov — at coordinate n km.
Driving for a long time may be really difficult. Formally, if Leha has already covered i kilometers since he stopped to have a rest, he considers the difficulty of covering (i + 1)-th kilometer as a_{i + 1}. It is guaranteed that for every i ∈ [1, n - 1] a_i ≤ a_{i + 1}. The difficulty of the journey is denoted as the sum of difficulties of each kilometer in the journey.
Fortunately, there may be some rest sites between Moscow and Saratov. Every integer point from 1 to n - 1 may contain a rest site. When Leha enters a rest site, he may have a rest, and the next kilometer will have difficulty a_1, the kilometer after it — difficulty a_2, and so on.
For example, if n = 5 and there is a rest site in coordinate 2, the difficulty of journey will be 2a_1 + 2a_2 + a_3: the first kilometer will have difficulty a_1, the second one — a_2, then Leha will have a rest, and the third kilometer will have difficulty a_1, the fourth — a_2, and the last one — a_3. Another example: if n = 7 and there are rest sites in coordinates 1 and 5, the difficulty of Leha's journey is 3a_1 + 2a_2 + a_3 + a_4.
Leha doesn't know which integer points contain rest sites. So he has to consider every possible situation. Obviously, there are 2^{n - 1} different distributions of rest sites (two distributions are different if there exists some point x such that it contains a rest site in exactly one of these distributions). Leha considers all these distributions to be equiprobable. He wants to calculate p — the expected value of difficulty of his journey.
Obviously, p ⋅ 2^{n - 1} is an integer number. You have to calculate it modulo 998244353.
Input
The first line contains one number n (1 ≤ n ≤ 10^6) — the distance from Moscow to Saratov.
The second line contains n integer numbers a_1, a_2, ..., a_n (1 ≤ a_1 ≤ a_2 ≤ ... ≤ a_n ≤ 10^6), where a_i is the difficulty of i-th kilometer after Leha has rested.
Output
Print one number — p ⋅ 2^{n - 1}, taken modulo 998244353.
Examples
Input
2
1 2
Output
5
Input
4
1 3 3 7
Output
60
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
int power[1000010], a[1000010];
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
power[0] = 1;
for (int i = 1; i < 1000010; ++i) power[i] = power[i - 1] * 2 % mod;
int n, ans = 0;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
ans = a[n];
for (int i = 1; i < n; ++i)
ans = (ans + 1LL * a[i] * power[n - i - 1] % mod * (n + 2 - i) % mod) % mod;
printf("%d\n", ans);
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
Drazil has many friends. Some of them are happy and some of them are unhappy. Drazil wants to make all his friends become happy. So he invented the following plan.
There are n boys and m girls among his friends. Let's number them from 0 to n - 1 and 0 to m - 1 separately. In i-th day, Drazil invites <image>-th boy and <image>-th girl to have dinner together (as Drazil is programmer, i starts from 0). If one of those two people is happy, the other one will also become happy. Otherwise, those two people remain in their states. Once a person becomes happy (or if it is happy originally), he stays happy forever.
Drazil wants to know on which day all his friends become happy or to determine if they won't become all happy at all.
Input
The first line contains two integer n and m (1 ≤ n, m ≤ 109).
The second line contains integer b (0 ≤ b ≤ min(n, 105)), denoting the number of happy boys among friends of Drazil, and then follow b distinct integers x1, x2, ..., xb (0 ≤ xi < n), denoting the list of indices of happy boys.
The third line conatins integer g (0 ≤ g ≤ min(m, 105)), denoting the number of happy girls among friends of Drazil, and then follow g distinct integers y1, y2, ... , yg (0 ≤ yj < m), denoting the list of indices of happy girls.
It is guaranteed that there is at least one person that is unhappy among his friends.
Output
Print the number of the first day that all friends of Drazil become happy. If this day won't come at all, you print -1.
Examples
Input
2 3
0
1 0
Output
4
Input
2 4
1 0
1 2
Output
-1
Input
2 3
1 0
1 1
Output
2
Input
99999 100000
2 514 415
2 50216 61205
Output
4970100515
Note
By <image> we define the remainder of integer division of i by k.
In first sample case:
* On the 0-th day, Drazil invites 0-th boy and 0-th girl. Because 0-th girl is happy at the beginning, 0-th boy become happy at this day.
* On the 1-st day, Drazil invites 1-st boy and 1-st girl. They are both unhappy, so nothing changes at this day.
* On the 2-nd day, Drazil invites 0-th boy and 2-nd girl. Because 0-th boy is already happy he makes 2-nd girl become happy at this day.
* On the 3-rd day, Drazil invites 1-st boy and 0-th girl. 0-th girl is happy, so she makes 1-st boy happy.
* On the 4-th day, Drazil invites 0-th boy and 1-st girl. 0-th boy is happy, so he makes the 1-st girl happy. So, all friends become happy at this moment.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T &x) {
char c;
int f = 1;
x = 0;
while (((c = getchar()) < '0' || c > '9') && c != '-')
;
if (c == '-')
f = -1;
else
x = c - '0';
while ((c = getchar()) >= '0' && c <= '9') x = x * 10 + c - '0';
x *= f;
}
const int MAXN = 1e5 + 9;
const long long INF = 1LL << 60;
int n, m, d;
int x[MAXN], y[MAXN];
vector<int> p[MAXN << 1][2];
long long ans;
inline int gcd(int x, int y) {
while (y) y ^= x ^= y ^= x %= y;
return x;
}
inline void ext_gcd(int a, int b, int &x, int &y) {
if (!b) {
x = 1, y = 0;
return;
}
ext_gcd(b, a % b, y, x);
y -= a / b * x;
}
inline long long pow_mod(long long a, long long b, long long MOD) {
long long ret = 1, base = a;
while (b) {
if (b & 1) ret = ret * base % MOD;
base = base * base % MOD;
b >>= 1;
}
return ret;
}
inline int mod(int a, int b) {
while (a >= b) a -= b;
while (a < 0) a += b;
return a;
}
map<int, bool> vis;
vector<pair<int, int> > pos;
int inv[2];
long long mint[MAXN << 1];
bool in[MAXN << 1];
queue<int> q;
long long solve(vector<int> p[2]) {
long long ret = -INF;
int l[2] = {n, m};
for (int i = (0); i <= (1); ++i) {
pos.clear();
vis.clear();
for (int j = (0); j <= (1); ++j)
for (int k = (0); k <= ((int)p[j].size() - 1); ++k) {
pos.push_back(
make_pair((long long)p[j][k] % l[i] * inv[i] % l[i], p[j][k] * d));
if (i == j) vis[(long long)p[j][k] % l[i] * inv[i] % l[i]] = true;
}
sort(pos.begin(), pos.end());
int k = 0;
pos[k++] = pos[0];
for (int j = (1); j <= ((int)pos.size() - 1); ++j)
if (pos[j - 1].first != pos[j].first) pos[k++] = pos[j];
pos.resize(k);
for (int j = (0); j <= (k - 1); ++j) {
mint[j] = pos[j].second;
q.push(j), in[j] = true;
}
while (!q.empty()) {
int now = q.front(), ne;
long long val;
in[now] = false, q.pop();
if (mint[ne = mod(now + 1, k)] >
(val = mint[now] +
(long long)mod(pos[ne].first - pos[now].first + l[i], l[i]) *
l[i ^ 1] * d)) {
mint[ne] = val;
if (!in[ne]) {
in[ne] = true;
q.push(ne);
}
}
}
for (int j = (0); j <= (k - 1); ++j)
if (!vis[mod(pos[mod(j + 1, k)].first - 1 + l[i], l[i])])
ret = max(ret, mint[j] + (long long)mod(pos[mod(j + 1, k)].first -
pos[j].first - 1 + l[i],
l[i]) *
l[i ^ 1] * d);
}
return ret;
}
int main() {
read(n), read(m);
d = gcd(n, m);
n /= d, m /= d;
if (d >= MAXN) {
puts("-1");
return 0;
}
for (int i = (0); i <= (1); ++i) {
int tot;
read(tot);
for (int j = (0); j <= (tot - 1); ++j) {
int x;
read(x);
p[x % d][i].push_back(x / d);
}
}
for (int i = (0); i <= (d - 1); ++i)
if (p[i][0].size() + p[i][1].size() == 0) {
puts("-1");
return 0;
}
int tmp;
ext_gcd(m, n, inv[0], tmp), inv[0] = mod(inv[0], n);
ext_gcd(n, m, inv[1], tmp), inv[1] = mod(inv[1], m);
for (int i = (0); i <= (d - 1); ++i) ans = max(ans, solve(p[i]) + i);
cout << ans << endl;
return 0;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
You are given a string S consisting of `0` and `1`. Find the maximum integer K not greater than |S| such that we can turn all the characters of S into `0` by repeating the following operation some number of times.
* Choose a contiguous segment [l,r] in S whose length is at least K (that is, r-l+1\geq K must be satisfied). For each integer i such that l\leq i\leq r, do the following: if S_i is `0`, replace it with `1`; if S_i is `1`, replace it with `0`.
Constraints
* 1\leq |S|\leq 10^5
* S_i(1\leq i\leq N) is either `0` or `1`.
Input
Input is given from Standard Input in the following format:
S
Output
Print the maximum integer K such that we can turn all the characters of S into `0` by repeating the operation some number of times.
Examples
Input
010
Output
2
Input
100000000
Output
8
Input
00001111
Output
4
### Response
```cpp
#include<bits/stdc++.h>
using namespace std ;
int main()
{
string s ;
cin >> s ;
int ans = 1e7 ;
int n = s.size() ;
for(int i = 0 ; i < s.size() - 1 ; i++)
{
if(s[i] != s[i+1] )
ans =
min( ans , max(i+1 , n - i - 1)) ;
}
cout << min(n,ans) << endl ;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
You are developing frog-shaped robots, and decided to race them against each other.
First, you placed N robots onto a number line. These robots are numbered 1 through N. The current coordinate of robot i is x_i. Here, all x_i are integers, and 0 < x_1 < x_2 < ... < x_N.
You will repeatedly perform the following operation:
* Select a robot on the number line. Let the coordinate of the robot be x. Select the destination coordinate, either x-1 or x-2, that is not occupied by another robot. The robot now jumps to the selected coordinate.
When the coordinate of a robot becomes 0 or less, the robot is considered finished and will be removed from the number line immediately. You will repeat the operation until all the robots finish the race.
Depending on your choice in the operation, the N robots can finish the race in different orders. In how many different orders can the N robots finish the race? Find the answer modulo 10^9+7.
Constraints
* 2 ≤ N ≤ 10^5
* x_i is an integer.
* 0 < x_1 < x_2 < ... < x_N ≤ 10^9
Input
The input is given from Standard Input in the following format:
N
x_1 x_2 ... x_N
Output
Print the number of the different orders in which the N robots can finish the race, modulo 10^9+7.
Examples
Input
3
1 2 3
Output
4
Input
3
2 3 4
Output
6
Input
8
1 2 3 5 7 11 13 17
Output
10080
Input
13
4 6 8 9 10 12 14 15 16 18 20 21 22
Output
311014372
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll mod = 1e9 + 7;
int main()
{
int N;
cin >> N;
vector<int> x(N);
for (int i = 0; i < N; i++) {
cin >> x[i];
}
vector<int> v(N);
for (int i = 1; i < N; i++) {
v[i] = v[i - 1] + (x[i - 1] >= (i - v[i - 1]) * 2 - 1 ? 0 : 1);
}
ll res = 1;
for (int i = 0; i < N; i++) {
res = (res * (i + 1 - v[i])) % mod;
}
cout << res << endl;
return 0;
}
``` |
### Prompt
Your task is to create 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;
bool RANDOM = false;
using namespace std;
double EPS = 0.0000000001;
double INF = 1000000000000000.0;
ostream_iterator<long long int> oi(cout, " ");
long long int minInt = 1;
long long int maxInt = 100;
double minDouble = -100000000000.0;
double maxDouble = 100000000000.0;
void setMaxInt(long long int newMax) { maxInt = newMax; }
void setMinInt(long long int newMin) { minInt = newMin; }
void setIntRange(long long int min, long long int max) {
maxInt = max;
minInt = min;
}
void setMaxDouble(double newMax) { maxDouble = newMax; }
void setMinDouble(double newMin) { minDouble = newMin; }
void setDoubleRange(double min, double max) {
maxDouble = max;
minDouble = min;
}
ostream& operator<<(ostream& out, pair<long long int, long long int>& c) {
out << "<" << c.first << ", ";
out << c.second << ">" << endl;
return out;
}
void print() { std::cout << endl; }
template <typename A>
void print(A value) {
std::cout << value;
}
template <>
void print<double>(double value) {
printf("%lf", value);
}
template <typename A, typename B>
void print(A value1, B value2) {
cout << value1 << " " << value2;
}
template <typename A, typename B, typename C>
void print(A value1, B value2, C value3) {
cout << value1 << " " << value2 << " " << value3;
}
template <typename A, typename B, typename C, typename D>
void print(A value1, B value2, C value3, D value4) {
cout << value1 << " " << value2 << " " << value3 << " " << value4;
}
template <typename A>
void println(A value) {
std::cout << value << endl;
}
template <typename A, typename B>
void println(A value1, B value2) {
cout << value1 << " " << value2 << endl;
}
template <typename A, typename B, typename C>
void println(A value1, B value2, C value3) {
cout << value1 << " " << value2 << " " << value3 << endl;
}
template <typename A, typename B, typename C, typename D>
void println(A value1, B value2, C value3, D value4) {
cout << value1 << " " << value2 << " " << value3 << " " << value4 << endl;
}
long long int randomint(long long int min, long long int max) {
return rand() % (max - min + 1) + min;
}
double randomdouble(double min, double max) {
return (rand() / (double)RAND_MAX) * (max - min) + min;
}
template <typename E>
E read() {
E value;
cin >> value;
return value;
}
template <>
long long int read<long long int>() {
if (!RANDOM) {
long long int value;
cin >> value;
return value;
} else {
return randomint(minInt, maxInt);
}
}
template <>
double read<double>() {
if (!RANDOM) {
double value;
cin >> value;
return value;
} else {
return randomdouble(minDouble, maxDouble);
}
}
istream& operator>>(istream& in, pair<long long int, long long int>& c) {
c.first = read<long long int>();
c.second = read<long long int>();
return in;
}
ostream& operator<<(ostream& out, string& c) {
for (long long int i = 0; i < c.length(); i++) {
putchar(c[i]);
}
return out;
}
template <typename E>
class Array {
public:
long long int size;
Array<E>(long long int _capacity) {
capacity = _capacity;
array = new E[capacity];
size = capacity;
fill();
}
void sort() { std::sort(&array[0], &array[size]); }
Array() {
capacity = 4;
array = new E[capacity];
size = 0;
}
Array(vector<E>& vect) {
long long int _size = vect.size();
capacity = _size * 2;
size = _size;
array = new E[capacity];
for (long long int i = 0; i < size; i++) {
array[i] = vect[i];
}
}
Array(long long int minBound, long long int maxBound, long long int _size) {
srand(_size);
capacity = _size * 2;
size = _size;
array = new E[capacity];
for (long long int i = 0; i < size; i++) {
array[i] = randomint(minBound, maxBound);
}
}
void add(E item);
long long int leftBinarySearch(E& item);
long long int rightBinarySearch(E& item);
pair<long long int, long long int> equalRange(E& item);
bool binarySearch(E& item);
void fill();
E* begin();
E* end();
vector<E> toVector();
void toString(ostream& stream);
E& operator[](long long int i);
E& index(long long int i);
E* array;
private:
long long int capacity;
void ensureCapacity(long long int cap);
};
template <typename E>
void Array<E>::ensureCapacity(long long int cap) {
capacity = capacity * 2;
E* newArray = new E[capacity];
memcpy(newArray, array, sizeof(E) * size);
delete[] array;
array = newArray;
}
template <typename E>
void Array<E>::fill() {
for (long long int i = 0; i < size; i++) {
array[i] = 0;
}
}
template <>
void Array<pair<long long int, long long int> >::fill() {
for (long long int i = 0; i < size; i++) {
array[i] = make_pair(0, 0);
}
}
template <>
void Array<string>::fill() {
for (long long int i = 0; i < size; i++) {
array[i] = "";
}
}
template <typename E>
void Array<E>::toString(ostream& stream) {
long long int i = 0;
while (i < size) {
if (i == size - 1) {
stream << array[i];
} else {
stream << array[i] << " ";
}
i++;
}
stream << endl;
}
template <typename E>
void Array<E>::add(E item) {
if (capacity < size + 1) {
ensureCapacity(size + 1);
}
array[size] = item;
size++;
}
template <typename E>
E* Array<E>::begin() {
return array;
}
template <typename E>
E* Array<E>::end() {
return array + size;
}
template <typename E>
long long int Array<E>::leftBinarySearch(E& item) {
return lower_bound(array, array + size, item) - array;
}
template <typename E>
long long int Array<E>::rightBinarySearch(E& item) {
return upper_bound(array, array + size, item) - array;
}
template <typename E>
pair<long long int, long long int> Array<E>::equalRange(E& item) {
pair<long long int*, long long int*> p(0, 0);
p = equal_range(array, array + size, item);
return make_pair(p.first - array, p.second - array);
}
template <typename E>
bool Array<E>::binarySearch(E& item) {
return binary_search(array, array + size, item);
}
template <typename E>
vector<E> Array<E>::toVector() {
vector<E> res = vector<E>(size);
for (long long int i = 0; i < res.size(); i++) {
res[i] = array[i];
}
return res;
}
template <typename T>
ostream& operator<<(ostream& out, Array<T>& c) {
c.toString(out);
return out;
}
ostream& operator<<(ostream& out,
Array<pair<long long int, long long int> >& c) {
for (long long int i = 0; i < c.size; i++) {
out << c[i];
}
return out;
}
template <typename T>
istream& operator>>(istream& in, Array<T>& c) {
for (long long int i = 0; i < c.size; i++) {
c[i] = read<T>();
}
return in;
}
ostream& operator<<(ostream& out, map<long long int, long long int>& c) {
map<long long int, long long int>::iterator it = c.begin();
while (it != c.end()) {
pair<long long int, long long int> entry = *it;
out << entry;
it++;
}
return out;
}
Array<pair<long long int, long long int> > mapToArray(
map<long long int, long long int>& c) {
Array<pair<long long int, long long int> > res(c.size());
map<long long int, long long int>::iterator it = c.begin();
long long int i = 0;
while (it != c.end()) {
pair<long long int, long long int> entry = *it;
res[i] = entry;
i++;
it++;
}
return res;
}
template <typename E>
E& Array<E>::operator[](long long int i) {
if (i < size && i >= 0) {
return array[i];
} else {
cout << "Array index out of bounds, index is " << i << ", size is " << size
<< endl;
cout << "Array is " << endl;
toString(cout);
assert(0);
}
}
template <typename E>
class Matrix {
public:
long long int rows;
long long int columns;
Array<E> array;
E& get(long long int x, long long int y);
void set(long long int x, long long int y, E& value);
E& operator()(long long int x, long long int y);
Matrix<E> transpose();
pair<E*, E*> getRow(long long int y);
Matrix<E>(long long int c, long long int r) {
rows = r;
columns = c;
array = Array<E>(rows * columns);
array.fill();
}
void swap(Matrix<E>& other) {
std::swap(array, other.array);
std::swap(rows, other.rows);
std::swap(columns, other.columns);
}
Matrix<E>(long long int _columns, long long int _rows, long long int minBound,
long long int maxBound) {
rows = _rows;
columns = _columns;
long long int size = _rows * _columns;
array = Array<E>(minBound, maxBound, size);
}
private:
};
template <typename E>
Matrix<E> Matrix<E>::transpose() {
Matrix<long long int> b(rows, columns);
for (long long int x = 0; x < columns; x++) {
for (long long int y = 0; y < rows; y++) {
b(y, x) = array.array[x + y * columns];
}
}
return b;
}
template <typename E>
E& Matrix<E>::operator()(long long int x, long long int y) {
if (x >= columns || x < 0) {
cout << "x must be in range [0; " << columns - 1 << "], but it is " << x
<< endl;
assert(0);
}
if (y >= rows || y < 0) {
cout << "y must be in range [0; " << rows - 1 << "], but it is " << y
<< endl;
assert(0);
}
return array.array[x + y * columns];
}
template <typename T>
istream& operator>>(istream& in, Matrix<T>& c) {
for (long long int y = 0; y < c.rows; y++) {
for (long long int x = 0; x < c.columns; x++) {
c(x, y) = read<T>();
}
}
return in;
}
template <typename E>
pair<E*, E*> Matrix<E>::getRow(long long int y) {
E* f = array.array + y * columns;
E* s = array.array + (y + 1) * columns;
pair<E*, E*> p(f, s);
return p;
}
template <typename T>
ostream& operator<<(ostream& out, Matrix<T>& c) {
for (size_t y = 0; y < c.rows; y++) {
for (size_t x = 0; x < c.columns; x++) {
out << c(x, y) << " ";
}
out << endl;
}
return out;
}
class Point {
public:
double x;
double y;
Point(double _x, double _y) {
x = _x;
y = _y;
}
Point() {
x = 0;
y = 0;
}
};
double dist(Point& a, Point& b) {
double dx = a.x - b.x;
double dy = a.y - b.y;
return sqrt(dx * dx + dy * dy);
}
bool cmp(double a, double b) {
if (fabs(a - b) < EPS) {
return true;
} else {
return false;
}
}
class Triangle {
public:
Point A;
Point B;
Point C;
double a;
double b;
double c;
Triangle(Point _A, Point _B, Point _C) {
A = _A;
B = _B;
C = _C;
a = dist(C, B);
b = dist(C, A);
c = dist(A, B);
}
Triangle() {}
double S() {
return fabs((B.x - A.x) * (C.y - A.y) - (C.x - A.x) * (B.y - A.y));
}
};
class Line {
public:
double A;
double B;
double C;
double xmin;
double xmax;
Line(Point _A, Point _B, bool isSegment) { set(_A, _B, isSegment); }
void set(Point _A, Point _B, bool isSegment) {
if (isSegment) {
xmin = min(_A.x, _B.x);
xmax = max(_A.x, _B.x);
} else {
xmin = -INF;
xmax = INF;
}
double k = (_B.y - _A.y) / (_B.x - _A.x);
double b = _A.y - k * _A.x;
A = k;
B = -1.0;
C = b;
}
void setSegment(Point _A, Point _B) { set(_A, _B, true); }
void setLine(Point _A, Point _B) { set(_A, _B, false); }
double getY(double x) { return A * x + C; }
double length() {
double x1 = xmin;
double y1 = getY(xmin);
double x2 = xmax;
double y2 = getY(xmax);
return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}
long long int part(Point p) {
if (fabs(A) > 100000000.0) {
if (cmp(p.x, xmin)) {
return 0;
}
if (p.x > xmin) {
return 1;
} else {
return -1;
}
}
if (cmp(A * p.x + B * p.y + C, 0.0)) {
return 0;
}
if (A * p.x + B * p.y + C > 0) {
return 1;
}
if (A * p.x + B * p.y + C < 0) {
return -1;
}
}
};
istream& operator>>(istream& in, Point& c) {
c.x = read<long long int>();
c.y = read<long long int>();
return in;
}
ostream& operator<<(ostream& out, Point& c) {
out << "[" << c.x << ", " << c.y << "]" << endl;
return out;
}
istream& operator>>(istream& in, Triangle& c) {
in >> c.A;
in >> c.B;
in >> c.C;
return in;
}
ostream& operator<<(ostream& out, Triangle& c) {
out << c.A;
out << c.B;
out << c.C;
return out;
}
istream& operator>>(istream& in, Line& c) {
Point a;
Point b;
in >> a;
in >> b;
c.setLine(a, b);
return in;
}
ostream& operator<<(ostream& out, Line& c) {
cout << "y = " << c.A << "*x + " << c.C;
return out;
}
long long int bpow(long long int a, long long int b) {
if (b == 0) {
return 1;
} else {
if (b % 2 == 0) {
long long int half = bpow(a, b / 2);
return half * half;
} else {
return bpow(a, b - 1) * a;
}
}
}
long long int bpowmod(long long int a, long long int n, long long int mod) {
long long int res = 1;
while (n) {
if (n & 1) res = (a * res) % mod;
a = (a * a) % mod;
n >>= 1;
}
return res;
}
long long int fact(long long int n) {
if (n == 1) {
return 1;
} else {
return n * fact(n - 1);
}
}
long long int gcd(long long int a, long long int b) {
if (!b) {
return a;
} else {
return gcd(b, a % b);
}
}
Array<pair<long long int, long long int> > factorize(
long long int n, Array<long long int>& primeList) {
Array<pair<long long int, long long int> > res;
for (long long int j = 0; j < primeList.size; j++) {
long long int i = primeList[j];
if (n % i == 0) {
pair<long long int, long long int> comp = make_pair(i, 1);
n /= i;
while (n % i == 0) {
comp.second++;
n /= i;
}
res.add(comp);
}
}
if (n > 1) {
res.add(make_pair(n, 1));
}
return res;
}
long long int euler(long long int n, Array<long long int>& primeList) {
Array<pair<long long int, long long int> > fact = factorize(n, primeList);
long long int res = 1;
for (unsigned long long int i = 0; i < fact.size; i++) {
long long int factor =
pow((double)fact[i].first, (double)fact[i].second) -
pow((double)fact[i].first, (double)fact[i].second - 1);
res *= factor;
}
return res;
}
long long int inversePrime(long long int a, long long int m) {
return bpowmod(a, m - 2, m) % m;
}
long long int inverseCoprimes(long long int a, long long int m,
Array<long long int>& primeList) {
return bpow(a, euler(m, primeList) - 1) % m;
}
long long int inverse(long long int a, long long int m,
Array<long long int>& primeList) {
if (gcd(a, m) == 1) {
return inverseCoprimes(a, m, primeList);
} else {
assert(0);
return -1;
}
}
Array<long long int> enumerateDivisors(long long int n,
Array<long long int>& primeList) {
Array<pair<long long int, long long int> > divs = factorize(n, primeList);
vector<long long int> totals = vector<long long int>(divs.size + 1);
totals[0] = 1;
for (unsigned long long int i = 1; i < divs.size + 1; i++) {
totals[i] = totals[i - 1] * (divs[i - 1].second + 1);
}
Array<long long int> res;
for (long long int i = 0; i < totals[totals.size() - 1]; i++) {
vector<long long int> values = vector<long long int>(divs.size);
for (unsigned long long int j = 0; j < values.size(); j++) {
values[j] = (i / totals[j]) % (divs[j].second + 1);
}
long long int r = 1;
for (unsigned long long int i = 0; i < values.size(); i++) {
r *= bpow(divs[i].first, values[i]);
}
res.add(r);
}
return res;
}
void reverse(char* str) {
char temp;
size_t len = strlen(str) - 1;
size_t i;
size_t k = len;
for (i = 0; i < len; i++) {
temp = str[k];
str[k] = str[i];
str[i] = temp;
k--;
if (k == (len / 2)) {
break;
}
}
}
map<long long int, long long int> count(Array<long long int> a) {
map<long long int, long long int> res;
for (long long int i = 0; i < a.size; i++) {
res[a[i]]++;
}
return res;
}
void itoa(long long int n, char s[]) {
long long int radix = 10;
long long int i, sign;
if ((sign = n) < 0) n = -n;
i = 0;
do {
s[i++] = n % radix + '0';
} while ((n /= radix) > 0);
if (sign < 0) s[i++] = '-';
s[i] = '\0';
reverse(s);
}
long long int* vectorToArray(vector<long long int> v) {
long long int* a = new long long int[v.size()];
for (unsigned long long int i = 0; i < v.size(); i++) {
a[i] = v[i];
}
return a;
}
char* stringToNumber(long long int number) {
char* res = new char[100];
itoa(number, res);
return res;
}
long long int numberToString(char* str) { return atoi(str); }
long long int booleanAnswerBinarySearch(Array<long long int> params,
long long int left, long long int right,
bool (*f)(Array<long long int> params,
long long int v)) {
if (f(params, left) && !f(params, left - 1)) {
return left;
}
if (f(params, right) && !f(params, right + 1)) {
return right;
}
long long int middle = (left + right) / 2;
long long int g = f(params, middle);
if (g) {
return booleanAnswerBinarySearch(params, left, middle, f);
} else {
return booleanAnswerBinarySearch(params, middle + 1, right, f);
}
}
Array<Array<long long int> > enumerarePermutations(long long int n) {
long long int fac = fact(n);
Array<long long int> v;
for (long long int i = 0; i < n; i++) {
v.add(i + 1);
}
Array<Array<long long int> > res;
for (long long int i = 0; i < fac - 1; i++) {
Array<long long int> c(n);
copy(v.array, v.array + v.size, c.array);
res.add(c);
next_permutation(v.array, v.array + v.size);
}
Array<long long int> c(n);
copy(v.array, v.array + v.size, c.array);
res.add(c);
return res;
}
template <typename T>
Array<Array<T> > enumerarePermutations(Array<T>& array) {
long long int n = array.size;
long long int fac = fact(n);
Array<T> v;
for (long long int i = 0; i < n; i++) {
v.add(array[i]);
}
Array<Array<T> > res;
for (long long int i = 0; i < fac - 1; i++) {
Array<T> c(n);
copy(v.array, v.array + v.size, c.array);
res.add(c);
next_permutation(v.array, v.array + v.size);
}
Array<T> c(n);
copy(v.array, v.array + v.size, c.array);
res.add(c);
return res;
}
Array<Array<long long int> > enumerareTuples(long long int n, long long int k) {
long long int q = bpow(k, n);
Array<Array<long long int> > res(q);
for (long long int i = 0; i < q; i++) {
Array<long long int> tuple(n);
for (long long int j = 0; j < n; j++) {
tuple[j] = (i / bpow(k, j)) % k;
}
res[i] = tuple;
}
return res;
}
template <typename T>
Array<Array<long long int> > enumerareTuples(long long int n, Array<T> array) {
long long int k = array.size;
long long int q = bpow(k, n);
Array<Array<T> > res(q);
for (long long int i = 0; i < q; i++) {
Array<long long int> tuple(n);
for (long long int j = 0; j < n; j++) {
tuple[j] = array[(i / bpow(k, j)) % k];
}
res[i] = tuple;
}
return res;
}
bool* sieve(long long int bound) {
bool* array = new bool[bound + 1]();
for (long long int i = 2; i * i <= bound; i++) {
if (!array[i]) {
for (long long int j = i + i; j <= bound; j += i) {
array[j] = 1;
}
}
}
return array;
}
Array<long long int> sieveList(long long int bound) {
bool* array = new bool[bound + 1]();
for (long long int i = 2; i * i <= bound; i++) {
if (!array[i]) {
for (long long int j = i + i; j <= bound; j += i) {
array[j] = 1;
}
}
}
Array<long long int> a;
for (long long int i = 2; i < bound + 1; i++) {
if (!array[i]) {
a.add(i);
}
}
return a;
}
long long int f(long long int k) { return k & (k + 1); }
string alignLeft(string a, long long int length, char ch) {
if (a.length() < length) {
a = string(length - a.length(), ch) + a;
}
return a;
}
string decToRadix(long long int n, long long int radix) {
string res("");
if (n == 0) {
res.push_back('0');
return res;
}
while (n) {
long long int digit = n % radix;
res.push_back((char)(digit + '0'));
n /= radix;
}
reverse(res.begin(), res.end());
return res;
}
long long int radixToDec(string s, long long int radix) {
long long int res = 0;
reverse(s.begin(), s.end());
for (long long int i = 0; i < s.length(); i++) {
res += (s[i] - '0') * bpow(radix, i);
}
return res;
}
class F {
public:
long long int (*f)(long long int, long long int);
long long int (*inverse)(long long int, long long int);
long long int NEUTRAL;
F(long long int (*pf)(long long int, long long int),
long long int (*pinverse)(long long int, long long int), long long int n) {
f = pf;
inverse = pinverse;
NEUTRAL = n;
}
F() {}
long long int operator()(long long int a, long long int b) { return f(a, b); }
long long int inversed(long long int a, long long int b) {
return inverse(a, b);
}
};
class BIT {
public:
F f;
Array<long long int> tree;
Array<long long int> array;
BIT(F func, Array<long long int> source) {
Array<long long int> arr(source.size);
copy(source.begin(), source.end(), arr.begin());
array = arr;
f = func;
Array<long long int> tr(source.size);
tree = tr;
for (long long int i = 0; i < source.size; i++) {
add(i, array[i]);
}
}
void add(long long int i, long long int delta) {
for (long long int u = i; u < tree.size; u = u | (u + 1)) {
tree[u] = f(tree[u], delta);
}
}
long long int value(long long int l, long long int r) {
return f.inversed(p(r), p(l - 1));
}
long long int p(long long int v) {
if (v < 0) {
return 0;
}
if (v == 0) {
return tree[0];
} else {
return f(tree[v], p((v & (v + 1)) - 1));
}
}
};
class Graph {
public:
long long int n = 0;
long long int m = 0;
vector<vector<long long int> > adj;
vector<vector<long long int> > w;
bool isDirected = false;
bool isWeighted = false;
Graph() {}
void setDirected() { this->isDirected = true; }
void setWeighted() { this->isWeighted = true; }
Graph(long long int n) {
this->n = n;
vector<vector<long long int> > _adj(2 * n + 1);
vector<vector<long long int> > _w(2 * n + 1);
adj = _adj;
w = _w;
}
void readByMatrix() {
bool last = this->isDirected;
this->isDirected = true;
for (long long int i = 0; i < n; i++) {
for (long long int j = 0; j < n; j++) {
long long int x;
cin >> x;
if (this->isWeighted) {
if (x != -1) {
this->addWeighted(i, j, x);
}
} else {
if (x != 0) {
this->add(i, j);
}
}
}
}
this->isDirected = last;
}
void printWeights() {
for (long long int i = 0; i < n; i++) {
cout << i << " {";
for (long long int j = 0; j < w[i].size(); j++) {
if (j != adj[i].size() - 1) {
cout << w[i][j] << " ";
} else {
cout << w[i][j];
}
}
cout << "}";
cout << endl;
}
}
void add(long long int a, long long int b) {
this->m++;
adj[a].push_back(b);
if (!this->isDirected) {
this->m++;
adj[b].push_back(a);
}
}
void addWeighted(long long int a, long long int b, long long int weight) {
this->m++;
adj[a].push_back(b);
w[a].push_back(weight);
if (!this->isDirected) {
this->m++;
adj[b].push_back(a);
w[b].push_back(weight);
}
}
void dfs(long long int v, long long int* p, vector<long long int>& graypath,
Array<long long int>& cycles, Array<long long int>& res,
Array<long long int>& outs, long long int* color) {
color[v] = 1;
res.add(v);
graypath.push_back(v);
for (long long int i = 0; i < adj[v].size(); i++) {
long long int u = adj[v][i];
if (color[u] == 0) {
p[u] = v;
dfs(u, p, graypath, cycles, res, outs, color);
}
if (color[u] == 1) {
if (p[v] != u) {
Array<long long int> cycle;
bool now = false;
for (long long int i = 0; i < graypath.size(); i++) {
if (graypath[i] == u) {
now = true;
}
if (now) {
cycle.add(graypath[i]);
}
if (graypath[i] == v) {
now = false;
}
}
cycles = cycle;
}
}
}
graypath.pop_back();
color[v] = 2;
outs.add(v);
}
Array<long long int> dfs(long long int number) {
long long int* color = new long long int[n]();
long long int* p = new long long int[n]();
Array<long long int> res;
Array<long long int> outs;
Array<long long int> cycles;
vector<long long int> path;
dfs(number, p, path, cycles, res, outs, color);
return res;
}
Array<Array<long long int> > findConnectedComponents() {
Array<Array<long long int> > res;
long long int* array = new long long int[n]();
for (long long int i = 0; i < n; i++) {
if (!array[i]) {
Array<long long int> component = dfs(i);
for (long long int j = 0; j < component.size; j++) {
array[component[j]] = i + 1;
}
res.add(component);
}
}
return res;
}
void shortestPath(Array<long long int>& p, long long int from,
long long int to, Array<long long int>& res) {
if (from == to) {
res.add(from);
} else {
res.add(to);
long long int newTo = p[to];
shortestPath(p, from, newTo, res);
}
}
Array<long long int> shortestPath(Array<long long int>& p, long long int from,
long long int to) {
Array<long long int> res;
shortestPath(p, from, to, res);
reverse(res.begin(), res.end());
return res;
}
Array<long long int> bfsPath(long long int s, long long int t) {
Array<long long int> p(n);
Array<long long int> dists(n);
bfs(p, dists, s);
for (long long int i = 0; i < n; i++) {
dists[i] = -1;
}
return shortestPath(p, s, t);
}
Array<long long int> bfsDists(long long int root) {
Array<long long int> p(n);
Array<long long int> dists(n);
for (long long int i = 0; i < n; i++) {
dists[i] = -1;
}
bfs(p, dists, root);
return dists;
}
Array<long long int> findCycles() {
long long int* color = new long long int[n]();
long long int* p = new long long int[n]();
Array<long long int> res;
Array<long long int> outs;
Array<long long int> cycles;
vector<long long int> graypath;
dfs(0, p, graypath, cycles, res, outs, color);
return cycles;
}
void bfs(Array<long long int>& p, Array<long long int>& dists,
long long int root) {
queue<long long int> q;
q.push(root);
long long int* visited = new long long int[this->n]();
visited[root] = true;
dists[root] = 0;
while (!q.empty()) {
long long int v = q.front();
q.pop();
for (long long int i = 0; i < adj[v].size(); i++) {
long long int u = adj[v][i];
if (!visited[u]) {
visited[u] = true;
dists[u] = dists[v] + 1;
p[u] = v;
q.push(u);
}
}
}
}
Array<long long int> toposort() {
n++;
vector<long long int> newAdj;
adj[n] = newAdj;
for (long long int i = 0; i < n - 1; i++) {
this->add(n - 1, i);
}
Array<long long int> res;
Array<long long int> outs;
vector<long long int> path;
Array<long long int> cycles;
long long int* color = new long long int[n]();
long long int* pr = new long long int[n]();
dfs(n - 1, pr, path, cycles, res, outs, color);
n--;
Array<long long int> p(outs.size - 1);
for (long long int i = 0; i < outs.size - 1; i++) {
p[i] = outs[i];
}
reverse(p.begin(), p.end());
Array<long long int> r(p.size);
for (long long int i = 0; i < p.size; i++) {
r[p[i]] = i;
}
for (long long int i = 0; i < n; i++) {
for (long long int j = 0; j < adj[i].size(); j++) {
long long int v = adj[i][j];
if (r[i] >= r[v]) {
Array<long long int> sh(0);
return sh;
}
}
}
return p;
}
long long int INF = 1000000000;
long long int INFP = 1000000000 / 2;
void Dijkstra(Array<long long int>& p, Array<long long int>& dists,
long long int root) {
for (long long int i = 0; i < n; i++) {
dists.add(this->INF);
}
dists[root] = 0;
for (long long int i = 0; i < n; i++) {
p.add(this->INF);
}
p[root] = root;
long long int* used = new long long int[n]();
long long int v = root;
for (long long int i = 0; i < n; i++) {
used[v] = true;
for (long long int j = 0; j < adj[v].size(); j++) {
long long int u = adj[v][j];
if (used[u] == false) {
long long int newD = dists[v] + w[v][j];
if (newD < dists[u]) {
p[u] = v;
dists[u] = newD;
}
}
}
long long int newV = -1;
long long int minDist = this->INF + this->INF;
for (long long int i = 0; i < n; i++) {
if (!used[i]) {
if (dists[i] < minDist) {
newV = i;
minDist = dists[i];
}
}
}
v = newV;
}
}
};
long long int clp2(long long int x) {
x--;
for (long long int p = 1; p < 32; p <<= 1) x |= (x >> p);
return ++x;
}
void fillArray(Array<long long int>& a) {
long long int need = clp2(a.size);
for (long long int i = a.size; i < need; i++) {
a.add(0);
}
}
long long int sumOfDigits(long long int n) {
long long int res = 0;
for (long long int x = n; x; x /= 10) {
res += x % 10;
}
return res;
}
long long int numOfDigits(long long int n) {
long long int res = 0;
for (long long int x = n; x; x /= 10) {
res++;
}
return res;
}
istream& operator>>(istream& in, Graph& g) {
long long int n;
long long int m;
cin >> n >> m;
Graph graph(n);
graph.isDirected = g.isDirected;
graph.isWeighted = g.isWeighted;
for (long long int i = 0; i < m; i++) {
long long int x;
long long int y;
cin >> x >> y;
if (!graph.isWeighted) {
graph.add(x - 1, y - 1);
} else {
long long int w;
cin >> w;
graph.addWeighted(x - 1, y - 1, w);
}
}
g = graph;
return in;
}
ostream& operator<<(ostream& out, Graph& g) {
for (long long int i = 0; i < g.n; i++) {
out << i << " {";
for (long long int j = 0; j < g.adj[i].size(); j++) {
if (j != g.adj[i].size() - 1) {
out << g.adj[i][j] << " ";
} else {
out << g.adj[i][j];
}
}
out << "}";
out << endl;
}
return out;
}
long long int compare(
pair<pair<long long int, long long int>, long long int> a,
pair<pair<long long int, long long int>, long long int> b) {
return a.first.second < b.first.second;
}
long long int mod = 1e9 + 7;
long long int factorials[3000001];
long long int C(long long int n, long long int k) {
long long int nfact = factorials[n];
long long int nkFact = factorials[n - k];
long long int kFact = factorials[k];
long long int invnkFact = inversePrime(nkFact, mod);
long long int invkFact = inversePrime(kFact, mod);
long long int res = nfact;
res = (res * invnkFact) % mod;
res = (res * invkFact) % mod;
return res;
}
int main(void) {
RANDOM = 0;
srand(time(0));
cout.precision(20);
std::ios::sync_with_stdio(false);
long long int n;
cin >> n;
factorials[0] = 1;
for (long long int i = 1; i <= 3000000; i++) {
factorials[i] = (factorials[i - 1] * i) % mod;
}
long long int res = 0;
for (long long int k = n + 1; k <= n + 1 + n; k++) {
long long int a1 = k;
long long int a2 = k - n;
long long int r = C(a1, a2);
res = (r + res) % mod;
}
cout << res << endl;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
The Holmes children are fighting over who amongst them is the cleverest.
Mycroft asked Sherlock and Eurus to find value of f(n), where f(1) = 1 and for n ≥ 2, f(n) is the number of distinct ordered positive integer pairs (x, y) that satisfy x + y = n and gcd(x, y) = 1. The integer gcd(a, b) is the greatest common divisor of a and b.
Sherlock said that solving this was child's play and asked Mycroft to instead get the value of <image>. Summation is done over all positive integers d that divide n.
Eurus was quietly observing all this and finally came up with her problem to astonish both Sherlock and Mycroft.
She defined a k-composite function Fk(n) recursively as follows:
<image>
She wants them to tell the value of Fk(n) modulo 1000000007.
Input
A single line of input contains two space separated integers n (1 ≤ n ≤ 1012) and k (1 ≤ k ≤ 1012) indicating that Eurus asks Sherlock and Mycroft to find the value of Fk(n) modulo 1000000007.
Output
Output a single integer — the value of Fk(n) modulo 1000000007.
Examples
Input
7 1
Output
6
Input
10 2
Output
4
Note
In the first case, there are 6 distinct ordered pairs (1, 6), (2, 5), (3, 4), (4, 3), (5, 2) and (6, 1) satisfying x + y = 7 and gcd(x, y) = 1. Hence, f(7) = 6. So, F1(7) = f(g(7)) = f(f(7) + f(1)) = f(6 + 1) = f(7) = 6.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
long long phi(long long n) {
if (n == 1) return 1;
long long res = n;
for (long long i = 2; i * i <= n; ++i) {
if (n % i) continue;
while (!(n % i)) n /= i;
res -= res / i;
}
if (n != 1) res -= res / n;
return res;
}
int main() {
long long n, k;
cin >> n >> k;
k = (k + 1) / 2;
while (k && n != 1) {
n = phi(n);
--k;
}
cout << n % MOD;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
Instructors of Some Informatics School make students go to bed.
The house contains n rooms, in each room exactly b students were supposed to sleep. However, at the time of curfew it happened that many students are not located in their assigned rooms. The rooms are arranged in a row and numbered from 1 to n. Initially, in i-th room there are ai students. All students are currently somewhere in the house, therefore a1 + a2 + ... + an = nb. Also 2 instructors live in this house.
The process of curfew enforcement is the following. One instructor starts near room 1 and moves toward room n, while the second instructor starts near room n and moves toward room 1. After processing current room, each instructor moves on to the next one. Both instructors enter rooms and move simultaneously, if n is odd, then only the first instructor processes the middle room. When all rooms are processed, the process ends.
When an instructor processes a room, she counts the number of students in the room, then turns off the light, and locks the room. Also, if the number of students inside the processed room is not equal to b, the instructor writes down the number of this room into her notebook (and turns off the light, and locks the room). Instructors are in a hurry (to prepare the study plan for the next day), so they don't care about who is in the room, but only about the number of students.
While instructors are inside the rooms, students can run between rooms that are not locked and not being processed. A student can run by at most d rooms, that is she can move to a room with number that differs my at most d. Also, after (or instead of) running each student can hide under a bed in a room she is in. In this case the instructor will not count her during the processing. In each room any number of students can hide simultaneously.
Formally, here is what's happening:
* A curfew is announced, at this point in room i there are ai students.
* Each student can run to another room but not further than d rooms away from her initial room, or stay in place. After that each student can optionally hide under a bed.
* Instructors enter room 1 and room n, they count students there and lock the room (after it no one can enter or leave this room).
* Each student from rooms with numbers from 2 to n - 1 can run to another room but not further than d rooms away from her current room, or stay in place. Each student can optionally hide under a bed.
* Instructors move from room 1 to room 2 and from room n to room n - 1.
* This process continues until all rooms are processed.
Let x1 denote the number of rooms in which the first instructor counted the number of non-hidden students different from b, and x2 be the same number for the second instructor. Students know that the principal will only listen to one complaint, therefore they want to minimize the maximum of numbers xi. Help them find this value if they use the optimal strategy.
Input
The first line contains three integers n, d and b (2 ≤ n ≤ 100 000, 1 ≤ d ≤ n - 1, 1 ≤ b ≤ 10 000), number of rooms in the house, running distance of a student, official number of students in a room.
The second line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 109), i-th of which stands for the number of students in the i-th room before curfew announcement.
It is guaranteed that a1 + a2 + ... + an = nb.
Output
Output one integer, the minimal possible value of the maximum of xi.
Examples
Input
5 1 1
1 0 0 0 4
Output
1
Input
6 1 2
3 8 0 1 0 0
Output
2
Note
In the first sample the first three rooms are processed by the first instructor, and the last two are processed by the second instructor. One of the optimal strategies is the following: firstly three students run from room 5 to room 4, on the next stage two of them run to room 3, and one of those two hides under a bed. This way, the first instructor writes down room 2, and the second writes down nothing.
In the second sample one of the optimal strategies is the following: firstly all students in room 1 hide, all students from room 2 run to room 3. On the next stage one student runs from room 3 to room 4, and 5 students hide. This way, the first instructor writes down rooms 1 and 2, the second instructor writes down rooms 5 and 6.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pi = pair<ll, ll>;
using vi = vector<ll>;
template <class T>
using vc = vector<T>;
template <class T>
using vvc = vector<vc<T>>;
template <class T>
using vvvc = vector<vvc<T>>;
template <class T>
using vvvvc = vector<vvvc<T>>;
template <class T>
using pq = priority_queue<T>;
template <class T>
using pqg = priority_queue<T, vector<T>, greater<T>>;
template <class T>
T ceil(T x, T y) {
assert(y >= 1);
return (x > 0 ? (x + y - 1) / y : x / y);
}
template <class T>
T floor(T x, T y) {
assert(y >= 1);
return (x > 0 ? x / y : (x - y + 1) / y);
}
void scan(int &a) { cin >> a; }
void scan(long long &a) { cin >> a; }
void scan(char &a) { cin >> a; }
void scan(double &a) { cin >> a; }
void scan(long double &a) { cin >> a; }
void scan(string &a) { cin >> a; }
template <class T, class S>
void scan(pair<T, S> &p) {
scan(p.first), scan(p.second);
}
template <class T>
void scan(vector<T> &a) {
for (auto &i : a) scan(i);
}
template <class T>
void scan(T &a) {
cin >> a;
}
void IN() {}
template <class Head, class... Tail>
void IN(Head &head, Tail &...tail) {
scan(head);
IN(tail...);
}
vi s_to_vi(string S, char first_char = 'a') {
vi A(S.size());
for (ll i = 0; (i) < (ll)(S.size()); ++(i)) {
A[i] = S[i] - first_char;
}
return A;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &A) {
os << A.first << " " << A.second;
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &A) {
for (size_t i = 0; i < A.size(); i++) {
if (i) os << " ";
os << A[i];
}
return os;
}
void print() { cout << "\n"; }
template <class Head, class... Tail>
void print(Head &&head, Tail &&...tail) {
cout << head;
if (sizeof...(Tail)) cout << " ";
print(forward<Tail>(tail)...);
}
const string YESNO[2] = {"NO", "YES"};
const string YesNo[2] = {"No", "Yes"};
const string yesno[2] = {"no", "yes"};
void YES(bool t = 1) { cout << YESNO[t] << endl; }
void NO(bool t = 1) { YES(!t); }
void Yes(bool t = 1) { cout << YesNo[t] << endl; }
void No(bool t = 1) { Yes(!t); }
void yes(bool t = 1) { cout << yesno[t] << endl; }
void no(bool t = 1) { yes(!t); }
template <typename T>
vector<T> cumsum(vector<T> A) {
ll N = A.size();
vector<T> B(N + 1);
B[0] = T(0);
for (ll i = 0; (i) < (ll)(N); ++(i)) {
B[i + 1] = B[i] + A[i];
}
return B;
}
vi bin_count(vi &A, ll size) {
vi C(size);
for (auto &&x : A) {
++C[x];
}
return C;
}
template <typename T>
vi argsort(vector<T> &A) {
vi ids(A.size());
iota(ids.begin(), ids.end(), 0);
sort(ids.begin(), ids.end(),
[&](ll i, ll j) { return make_pair(A[i], i) <= make_pair(A[j], j); });
return ids;
}
template <class T, class S>
inline bool chmax(T &a, const S &b) {
return (a < b ? a = b, 1 : 0);
}
template <class T, class S>
inline bool chmin(T &a, const S &b) {
return (a > b ? a = b, 1 : 0);
}
void solve() {
ll N, D, B;
IN(N, D, B);
vector<ll> A(N);
IN(A);
auto A_cum = cumsum(A);
ll ANS = 0;
ll x = 0;
for (ll i = 0; (i) < (ll)(N / 2); ++(i)) {
ll R = min(N, i + D * (i + 1) + 1);
if (A_cum[R] >= B + x * B) ++x;
}
chmax(ANS, N / 2 - x);
x = 0;
for (ll i = (ll)(N)-1; (i) >= (ll)(N / 2); --(i)) {
ll L = max(0LL, i - D * (N - i));
if (A_cum[N] - A_cum[L] >= B + x * B) ++x;
}
chmax(ANS, N - N / 2 - x);
print(ANS);
}
signed main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << setprecision(15);
solve();
return 0;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
Bizon the Champion isn't just friendly, he also is a rigorous coder.
Let's define function f(a), where a is a sequence of integers. Function f(a) returns the following sequence: first all divisors of a1 go in the increasing order, then all divisors of a2 go in the increasing order, and so on till the last element of sequence a. For example, f([2, 9, 1]) = [1, 2, 1, 3, 9, 1].
Let's determine the sequence Xi, for integer i (i ≥ 0): X0 = [X] ([X] is a sequence consisting of a single number X), Xi = f(Xi - 1) (i > 0). For example, at X = 6 we get X0 = [6], X1 = [1, 2, 3, 6], X2 = [1, 1, 2, 1, 3, 1, 2, 3, 6].
Given the numbers X and k, find the sequence Xk. As the answer can be rather large, find only the first 105 elements of this sequence.
Input
A single line contains two space-separated integers — X (1 ≤ X ≤ 1012) and k (0 ≤ k ≤ 1018).
Output
Print the elements of the sequence Xk in a single line, separated by a space. If the number of elements exceeds 105, then print only the first 105 elements.
Examples
Input
6 1
Output
1 2 3 6
Input
4 2
Output
1 1 2 1 2 4
Input
10 3
Output
1 1 1 2 1 1 5 1 1 2 1 5 1 2 5 10
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int INF = 2000000000;
const double pi = acos(-1.0);
long long int x, k, ctr = 0;
int flag = 0;
vector<long long int> divisors;
void getdivisors() {
for (long long int i = 1; i * i <= x; i++) {
if (x % i == 0) {
divisors.push_back(i);
if (x / i != i) {
divisors.push_back(x / i);
}
}
}
}
void DFS(long long int val, int depth) {
if (depth == k || val == 1) {
cout << val << " ";
ctr++;
if (ctr == 100000) {
flag = 1;
return;
}
return;
}
for (int i = 0; i < (int)divisors.size() && divisors[i] <= val && !flag;
i++) {
if (val % divisors[i] == 0) DFS(divisors[i], depth + 1);
}
}
int main() {
std::ios_base::sync_with_stdio(false);
while (cin >> x >> k) {
divisors.clear();
getdivisors();
sort(divisors.begin(), divisors.end());
DFS(x, 0);
cout << endl;
}
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
You are given a ternary string (it is a string which consists only of characters '0', '1' and '2').
You can swap any two adjacent (consecutive) characters '0' and '1' (i.e. replace "01" with "10" or vice versa) or any two adjacent (consecutive) characters '1' and '2' (i.e. replace "12" with "21" or vice versa).
For example, for string "010210" we can perform the following moves:
* "010210" → "100210";
* "010210" → "001210";
* "010210" → "010120";
* "010210" → "010201".
Note than you cannot swap "02" → "20" and vice versa. You cannot perform any other operations with the given string excluding described above.
You task is to obtain the minimum possible (lexicographically) string by using these swaps arbitrary number of times (possibly, zero).
String a is lexicographically less than string b (if strings a and b have the same length) if there exists some position i (1 ≤ i ≤ |a|, where |s| is the length of the string s) such that for every j < i holds a_j = b_j, and a_i < b_i.
Input
The first line of the input contains the string s consisting only of characters '0', '1' and '2', its length is between 1 and 10^5 (inclusive).
Output
Print a single string — the minimum possible (lexicographically) string you can obtain by using the swaps described above arbitrary number of times (possibly, zero).
Examples
Input
100210
Output
001120
Input
11222121
Output
11112222
Input
20
Output
20
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
string temp = "";
long c1 = 0;
for (long i = 0; i < s.length(); i++) {
if (s[i] == '0' || s[i] == '2')
temp += s[i];
else
c1++;
}
long i = 0;
while (temp[i] == '0') {
cout << 0;
i++;
}
while (c1--) cout << 1;
for (long j = i; temp[j] != '\0'; j++) cout << temp[j] - '0';
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
There is a right triangle with legs of length a and b. Your task is to determine whether it is possible to locate the triangle on the plane in such a way that none of its sides is parallel to the coordinate axes. All the vertices must have integer coordinates. If there exists such a location, you have to output the appropriate coordinates of vertices.
Input
The first line contains two integers a, b (1 ≤ a, b ≤ 1000), separated by a single space.
Output
In the first line print either "YES" or "NO" (without the quotes) depending on whether the required location exists. If it does, print in the next three lines three pairs of integers — the coordinates of the triangle vertices, one pair per line. The coordinates must be integers, not exceeding 109 in their absolute value.
Examples
Input
1 1
Output
NO
Input
5 5
Output
YES
2 1
5 5
-2 4
Input
5 10
Output
YES
-10 4
-2 -2
1 2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1010;
int a, b;
pair<int, int> p1[10000], p2[10000];
inline bool isgood(int x) {
for (int i = 1; i <= 1005; i++) {
if (i * i == x) return true;
}
return false;
}
int main() {
cin >> a >> b;
int l1 = a * a;
int l2 = b * b;
int h1 = 0, h2 = 0;
for (int i = 1; i * i <= l1; i++) {
if (isgood(l1 - i * i)) p1[h1++] = make_pair(i, (int)sqrt(l1 - i * i));
}
for (int i = 1; i * i <= l2; i++) {
if (isgood(l2 - i * i)) p2[h2++] = make_pair(i, (int)sqrt(l2 - i * i));
}
pair<int, int> tmp1, tmp2;
bool ok = false;
for (int i = 0; i < h1; i++) {
for (int j = 0; j < h2; j++) {
if (p1[i].first * p2[j].first == p1[i].second * p2[j].second) {
if (p1[i].first == p1[i].second && p1[i].first == p2[j].first) continue;
tmp1 = make_pair(-p1[i].first, p1[i].second);
tmp2 = p2[j];
ok = true;
break;
} else if (p1[i].first * p2[j].second == p1[i].second * p2[j].first) {
if (p1[i].first == p1[i].second && p1[i].first == p2[j].first) continue;
tmp1 = make_pair(-p1[i].second, p1[i].first);
tmp2 = p2[j];
ok = true;
break;
}
}
if (ok) break;
}
pair<int, int> cankao = make_pair(0, 0);
if (!ok) {
cout << "NO";
return 0;
}
cout << "YES" << endl;
if (tmp1.first == tmp2.first) {
cout << 0 << " " << 0 << endl;
cout << -tmp1.first << " " << -tmp1.second << endl;
cout << tmp2.first << " " << tmp2.second;
} else if (tmp1.second == tmp2.second) {
cout << 0 << " " << 0 << endl;
cout << -tmp1.first << " " << -tmp1.second << endl;
cout << tmp2.first << " " << tmp2.second;
} else {
cout << 0 << " " << 0 << endl;
cout << tmp1.first << " " << tmp1.second << endl;
cout << tmp2.first << " " << tmp2.second;
}
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
<image>
While trading on his favorite exchange trader William realized that he found a vulnerability. Using this vulnerability he could change the values of certain internal variables to his advantage. To play around he decided to change the values of all internal variables from a_1, a_2, …, a_n to -a_1, -a_2, …, -a_n. For some unknown reason, the number of service variables is always an even number.
William understands that with his every action he attracts more and more attention from the exchange's security team, so the number of his actions must not exceed 5 000 and after every operation no variable can have an absolute value greater than 10^{18}. William can perform actions of two types for two chosen variables with indices i and j, where i < j:
1. Perform assignment a_i = a_i + a_j
2. Perform assignment a_j = a_j - a_i
William wants you to develop a strategy that will get all the internal variables to the desired values.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 20). Description of the test cases follows.
The first line of each test case contains a single even integer n (2 ≤ n ≤ 10^3), which is the number of internal variables.
The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9), which are initial values of internal variables.
Output
For each test case print the answer in the following format:
The first line of output must contain the total number of actions k, which the strategy will perform. Note that you do not have to minimize k. The inequality k ≤ 5 000 must be satisfied.
Each of the next k lines must contain actions formatted as "type i j", where "type" is equal to "1" if the strategy needs to perform an assignment of the first type and "2" if the strategy needs to perform an assignment of the second type. Note that i < j should hold.
We can show that an answer always exists.
Example
Input
2
4
1 1 1 1
4
4 3 1 2
Output
8
2 1 2
2 1 2
2 1 3
2 1 3
2 1 4
2 1 4
1 1 2
1 1 2
8
2 1 4
1 2 4
1 2 4
1 2 4
1 3 4
1 1 2
1 1 2
1 1 4
Note
For the first sample test case one possible sequence of operations is as follows:
1. "2 1 2". Values of variables after performing the operation: [1, 0, 1, 1]
2. "2 1 2". Values of variables after performing the operation: [1, -1, 1, 1]
3. "2 1 3". Values of variables after performing the operation: [1, -1, 0, 1]
4. "2 1 3". Values of variables after performing the operation: [1, -1, -1, 1]
5. "2 1 4". Values of variables after performing the operation: [1, -1, -1, 0]
6. "2 1 4". Values of variables after performing the operation: [1, -1, -1, -1]
7. "1 1 2". Values of variables after performing the operation: [0, -1, -1, -1]
8. "1 1 2". Values of variables after performing the operation: [-1, -1, -1, -1]
For the second sample test case one possible sequence of operations is as follows:
1. "2 1 4". Values of variables after performing the operation: [4, 3, 1, -2]
2. "1 2 4". Values of variables after performing the operation: [4, 1, 1, -2]
3. "1 2 4". Values of variables after performing the operation: [4, -1, 1, -2]
4. "1 2 4". Values of variables after performing the operation: [4, -3, 1, -2]
5. "1 3 4". Values of variables after performing the operation: [4, -3, -1, -2]
6. "1 1 2". Values of variables after performing the operation: [1, -3, -1, -2]
7. "1 1 2". Values of variables after performing the operation: [-2, -3, -1, -2]
8. "1 1 4". Values of variables after performing the operation: [-4, -3, -1, -2]
### Response
```cpp
//#pragma comment(linker, "/STACK:102400000,102400000")
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
//#define int ll
typedef pair<int,int>pii;
#define ff first
#define ss second
#define debug(x) std:: cerr << #x << " = " << x << std::endl;
const int maxn=2e5+10,inf=0x3f3f3f3f,mod=1000000007;
const ll INF=0x3f3f3f3f3f3f3f3f;
const double eps=1e-9;
//#define DEBUG//#define lowbit(x) ((x) & -(x))//<<setiosflags(ios::fixed)<<setprecision(9)
void read(){}
template<typename T,typename... T2>inline void read(T &x,T2 &... oth) {
x=0; int ch=getchar(),f=0;
while(ch<'0'||ch>'9'){if (ch=='-') f=1;ch=getchar();}
while (ch>='0'&&ch<='9'){x=(x<<1)+(x<<3)+(ch^48);ch=getchar();}
if(f)x=-x;
read(oth...);
}
int a[maxn];
void ope(int &x,int &y)
{
x+=y;
x+=y;
y-=x;
x+=y;
// y+=x;
x+=y;
y-=x;
}
void show(int x,int y)
{
printf("1 %d %d\n",x,y);
printf("1 %d %d\n",x,y);
printf("2 %d %d\n",x,y);
printf("1 %d %d\n",x,y);
// printf("1 %d %d\n",y,x);
printf("1 %d %d\n",x,y);
printf("2 %d %d\n",x,y);
}
signed main(signed argc, char const *argv[])
{
std::ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
#ifdef DEBUG
freopen("input.in", "r", stdin);
// freopen("output.out", "w", stdout);
#endif
int t,n;
scanf("%d",&t);
// cin>>t;
while(t--)
{
scanf("%d",&n);
// cin>>n;
for(int i=1;i<=n;i++)
scanf("%d",&a[i]);
// cin>>a[i];
printf("%d\n",3*n);
for(int i=1;i<=n;i+=2)
{
show(i,i+1);
// show(i,i+1);
// ope(a[i],a[i+1]);
// ope(a[i],a[i+1]);
}
// for(int i=1;i<=n;i++)
// cerr<<a[i]<<' ';
// cerr<<endl;
}
return 0;
}
/*
* 2021-05-30-22.55.50
* C:\Users\dell\Desktop\C++\网赛\2021年5月30日Deltix Round, Spring 2021 (open for everyone, rated, Div. 1 + Div. 2)\B.cpp
*
*/
``` |
### Prompt
Create a solution in cpp for the following problem:
After playing Neo in the legendary "Matrix" trilogy, Keanu Reeves started doubting himself: maybe we really live in virtual reality? To find if this is true, he needs to solve the following problem.
Let's call a string consisting of only zeroes and ones good if it contains different numbers of zeroes and ones. For example, 1, 101, 0000 are good, while 01, 1001, and 111000 are not good.
We are given a string s of length n consisting of only zeroes and ones. We need to cut s into minimal possible number of substrings s_1, s_2, …, s_k such that all of them are good. More formally, we have to find minimal by number of strings sequence of good strings s_1, s_2, …, s_k such that their concatenation (joining) equals s, i.e. s_1 + s_2 + ... + s_k = s.
For example, cuttings 110010 into 110 and 010 or into 11 and 0010 are valid, as 110, 010, 11, 0010 are all good, and we can't cut 110010 to the smaller number of substrings as 110010 isn't good itself. At the same time, cutting of 110010 into 1100 and 10 isn't valid as both strings aren't good. Also, cutting of 110010 into 1, 1, 0010 isn't valid, as it isn't minimal, even though all 3 strings are good.
Can you help Keanu? We can show that the solution always exists. If there are multiple optimal answers, print any.
Input
The first line of the input contains a single integer n (1≤ n ≤ 100) — the length of the string s.
The second line contains the string s of length n consisting only from zeros and ones.
Output
In the first line, output a single integer k (1≤ k) — a minimal number of strings you have cut s into.
In the second line, output k strings s_1, s_2, …, s_k separated with spaces. The length of each string has to be positive. Their concatenation has to be equal to s and all of them have to be good.
If there are multiple answers, print any.
Examples
Input
1
1
Output
1
1
Input
2
10
Output
2
1 0
Input
6
100011
Output
2
100 011
Note
In the first example, the string 1 wasn't cut at all. As it is good, the condition is satisfied.
In the second example, 1 and 0 both are good. As 10 isn't good, the answer is indeed minimal.
In the third example, 100 and 011 both are good. As 100011 isn't good, the answer is indeed minimal.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e4 + 6;
const long long mod = 998244353;
int n;
char str[maxn];
int l[maxn], r[maxn];
int main() {
scanf("%d", &n);
scanf("%s", str + 1);
if (n == 1) {
printf("1\n");
printf("%s", str + 1);
return 0;
}
int s = 0, t = 0;
for (int i = 1; i <= n; ++i) {
if (str[i] == '1')
s++;
else
t++;
}
if (s == t) {
printf("2\n");
printf("%c ", str[1]);
printf("%s", str + 2);
} else {
printf("1\n");
printf("%s", str + 1);
}
return 0;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
Valera the Horse is going to the party with friends. He has been following the fashion trends for a while, and he knows that it is very popular to wear all horseshoes of different color. Valera has got four horseshoes left from the last year, but maybe some of them have the same color. In this case he needs to go to the store and buy some few more horseshoes, not to lose face in front of his stylish comrades.
Fortunately, the store sells horseshoes of all colors under the sun and Valera has enough money to buy any four of them. However, in order to save the money, he would like to spend as little money as possible, so you need to help Valera and determine what is the minimum number of horseshoes he needs to buy to wear four horseshoes of different colors to a party.
Input
The first line contains four space-separated integers s1, s2, s3, s4 (1 ≤ s1, s2, s3, s4 ≤ 109) — the colors of horseshoes Valera has.
Consider all possible colors indexed with integers.
Output
Print a single integer — the minimum number of horseshoes Valera needs to buy.
Examples
Input
1 7 3 3
Output
1
Input
7 7 7 7
Output
3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int s[4], i, j, count = 0;
for (i = 0; i < 4; i++) cin >> s[i];
for (i = 0; i < 4; i++)
for (j = i + 1; j < 4; j++)
if ((s[i] == s[j]) && (s[i] != '.') && (s[j] != '.')) {
s[i] = '.';
count++;
}
cout << count;
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
Lee bought some food for dinner time, but Lee's friends eat dinner in a deadly way. Lee is so scared, he doesn't want to die, at least not before seeing Online IOI 2020...
There are n different types of food and m Lee's best friends. Lee has w_i plates of the i-th type of food and each friend has two different favorite types of food: the i-th friend's favorite types of food are x_i and y_i (x_i ≠ y_i).
Lee will start calling his friends one by one. Whoever is called will go to the kitchen and will try to eat one plate of each of his favorite food types. Each of the friends will go to the kitchen exactly once.
The only problem is the following: if a friend will eat at least one plate of food (in total) then he will be harmless. But if there is nothing left for him to eat (neither x_i nor y_i), he will eat Lee instead ×\\_×.
Lee can choose the order of friends to call, so he'd like to determine if he can survive dinner or not. Also, he'd like to know the order itself.
Input
The first line contains two integers n and m (2 ≤ n ≤ 10^5; 1 ≤ m ≤ 2 ⋅ 10^5) — the number of different food types and the number of Lee's friends.
The second line contains n integers w_1, w_2, …, w_n (0 ≤ w_i ≤ 10^6) — the number of plates of each food type.
The i-th line of the next m lines contains two integers x_i and y_i (1 ≤ x_i, y_i ≤ n; x_i ≠ y_i) — the favorite types of food of the i-th friend.
Output
If Lee can survive the dinner then print ALIVE (case insensitive), otherwise print DEAD (case insensitive).
Also, if he can survive the dinner, print the order Lee should call friends. If there are multiple valid orders, print any of them.
Examples
Input
3 3
1 2 1
1 2
2 3
1 3
Output
ALIVE
3 2 1
Input
3 2
1 1 0
1 2
1 3
Output
ALIVE
2 1
Input
4 4
1 2 0 1
1 3
1 2
2 3
2 4
Output
ALIVE
1 3 2 4
Input
5 5
1 1 1 2 1
3 4
1 2
2 3
4 5
4 5
Output
ALIVE
5 4 1 3 2
Input
4 10
2 4 1 4
3 2
4 2
4 1
3 1
4 1
1 3
3 2
2 1
3 1
2 4
Output
DEAD
Note
In the first example, any of the following orders of friends are correct : [1, 3, 2], [3, 1, 2], [2, 3, 1], [3, 2, 1].
In the second example, Lee should call the second friend first (the friend will eat a plate of food 1) and then call the first friend (the friend will eat a plate of food 2). If he calls the first friend sooner than the second one, then the first friend will eat one plate of food 1 and food 2 and there will be no food left for the second friend to eat.
### Response
```cpp
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
using namespace std;
namespace ywy {
inline int get() {
int n = 0;
char c;
while ((c = getchar()) || 23333)
if (c >= '0' && c <= '9') break;
n = c - '0';
while ((c = getchar()) || 23333) {
if (c >= '0' && c <= '9')
n = n * 10 + c - '0';
else
return n;
}
}
vector<int> vec[200010];
int xs[200010], ys[200010], cnt[200010], bv_pl[200010], bv[200010], que[200010];
void ywymain() {
int n = get(), m = get();
for (int i = 1; i <= n; i++) cnt[i] = get();
for (int i = 1; i <= m; i++) {
vec[xs[i] = get()].push_back(i);
vec[ys[i] = get()].push_back(i);
cnt[xs[i]]--;
cnt[ys[i]]--;
}
int head = 0, tail = 0;
for (int i = 1; i <= n; i++) {
if (cnt[i] >= 0) {
bv_pl[i] = 1;
for (int j : vec[i])
if (!bv[j]) bv[que[tail++] = j] = 1;
}
}
while (head < tail) {
int me = que[head++];
cnt[xs[me]]++;
cnt[ys[me]]++;
if (cnt[xs[me]] >= 0 && !bv_pl[xs[me]]) {
bv_pl[xs[me]] = 1;
for (int i : vec[xs[me]])
if (!bv[i]) bv[que[tail++] = i] = 1;
}
if (cnt[ys[me]] >= 0 && !bv_pl[ys[me]]) {
bv_pl[ys[me]] = 1;
for (int i : vec[ys[me]])
if (!bv[i]) bv[que[tail++] = i] = 1;
}
}
if (head < m) {
printf("DEAD\n");
return;
}
printf("ALIVE\n");
for (int i = tail - 1; i >= 0; i--) {
printf("%d", que[i]);
if (i) putchar(' ');
}
}
} // namespace ywy
int main() {
ywy::ywymain();
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
Petr likes to come up with problems about randomly generated data. This time problem is about random permutation. He decided to generate a random permutation this way: he takes identity permutation of numbers from 1 to n and then 3n times takes a random pair of different elements and swaps them. Alex envies Petr and tries to imitate him in all kind of things. Alex has also come up with a problem about random permutation. He generates a random permutation just like Petr but swaps elements 7n+1 times instead of 3n times. Because it is more random, OK?!
You somehow get a test from one of these problems and now you want to know from which one.
Input
In the first line of input there is one integer n (10^{3} ≤ n ≤ 10^{6}).
In the second line there are n distinct integers between 1 and n — the permutation of size n from the test.
It is guaranteed that all tests except for sample are generated this way: First we choose n — the size of the permutation. Then we randomly choose a method to generate a permutation — the one of Petr or the one of Alex. Then we generate a permutation using chosen method.
Output
If the test is generated via Petr's method print "Petr" (without quotes). If the test is generated via Alex's method print "Um_nik" (without quotes).
Example
Input
5
2 4 5 1 3
Output
Petr
Note
Please note that the sample is not a valid test (because of limitations for n) and is given only to illustrate input/output format. Your program still has to print correct answer to this test to get AC.
Due to randomness of input hacks in this problem are forbidden.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long m, n, a, b, c, ans, ar[1000001], k, paths[200010], visit[200010],
ans1;
bool boo;
long long er[1000010];
vector<long long> gr[200010], gr1[200010];
queue<long long> qq;
int main() {
string s;
std::ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> ar[i];
er[ar[i]] = i;
}
for (long long i = 1; i <= n; i++) {
if (ar[i] != i) {
a = ar[i];
b = ar[er[i]];
swap(ar[i], ar[er[i]]);
ans++;
swap(er[a], er[b]);
}
}
if (ans % 2 == n % 2) {
cout << "Petr";
return 0;
}
cout << "Um_nik";
}
``` |
### Prompt
Create a solution in CPP for the following problem:
There are n railway stations in Berland. They are connected to each other by n-1 railway sections. The railway network is connected, i.e. can be represented as an undirected tree.
You have a map of that network, so for each railway section you know which stations it connects.
Each of the n-1 sections has some integer value of the scenery beauty. However, these values are not marked on the map and you don't know them. All these values are from 1 to 10^6 inclusive.
You asked m passengers some questions: the j-th one told you three values:
* his departure station a_j;
* his arrival station b_j;
* minimum scenery beauty along the path from a_j to b_j (the train is moving along the shortest path from a_j to b_j).
You are planning to update the map and set some value f_i on each railway section — the scenery beauty. The passengers' answers should be consistent with these values.
Print any valid set of values f_1, f_2, ..., f_{n-1}, which the passengers' answer is consistent with or report that it doesn't exist.
Input
The first line contains a single integer n (2 ≤ n ≤ 5000) — the number of railway stations in Berland.
The next n-1 lines contain descriptions of the railway sections: the i-th section description is two integers x_i and y_i (1 ≤ x_i, y_i ≤ n, x_i ≠ y_i), where x_i and y_i are the indices of the stations which are connected by the i-th railway section. All the railway sections are bidirected. Each station can be reached from any other station by the railway.
The next line contains a single integer m (1 ≤ m ≤ 5000) — the number of passengers which were asked questions. Then m lines follow, the j-th line contains three integers a_j, b_j and g_j (1 ≤ a_j, b_j ≤ n; a_j ≠ b_j; 1 ≤ g_j ≤ 10^6) — the departure station, the arrival station and the minimum scenery beauty along his path.
Output
If there is no answer then print a single integer -1.
Otherwise, print n-1 integers f_1, f_2, ..., f_{n-1} (1 ≤ f_i ≤ 10^6), where f_i is some valid scenery beauty along the i-th railway section.
If there are multiple answers, you can print any of them.
Examples
Input
4
1 2
3 2
3 4
2
1 2 5
1 3 3
Output
5 3 5
Input
6
1 2
1 6
3 1
1 5
4 1
4
6 1 3
3 4 1
6 5 2
1 2 5
Output
5 3 1 2 1
Input
6
1 2
1 6
3 1
1 5
4 1
4
6 1 1
3 4 3
6 5 3
1 2 4
Output
-1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int mod = 1000000007;
int INF = 9999999;
long long a, b, c, d, e, f, n, m, k, l;
void createTree(vector<int> &parents, vector<int> &level,
vector<vector<int> > &mezoblebi) {
queue<pair<pair<int, int>, int> > q;
q.push({{1, 1}, 0});
level[1] = 0;
while (!q.empty()) {
int from = q.front().first.first;
int to = q.front().first.second;
int lvl = q.front().second;
q.pop();
parents[to] = from;
level[to] = lvl;
for (int i = 0; i < mezoblebi[to].size(); i++) {
int newTo = mezoblebi[to][i];
if (newTo != from) {
q.push({{to, newTo}, lvl + 1});
}
}
}
}
void makeEdge(vector<vector<int> > &grid, int from, int to, vector<int> &level,
vector<int> &parent, int value) {
while (from != to) {
if (level[from] > level[to]) {
grid[from][parent[from]] = max(value, grid[from][parent[from]]);
grid[parent[from]][from] = grid[from][parent[from]];
from = parent[from];
} else if (level[from] < level[to]) {
grid[parent[to]][to] = max(value, grid[parent[to]][to]);
grid[to][parent[to]] = grid[parent[to]][to];
to = parent[to];
} else {
grid[parent[to]][to] = max(value, grid[parent[to]][to]);
grid[to][parent[to]] = grid[parent[to]][to];
grid[from][parent[from]] = max(value, grid[from][parent[from]]);
grid[parent[from]][from] = grid[from][parent[from]];
from = parent[from];
to = parent[to];
}
}
}
bool check(vector<vector<int> > &grid, int from, int to, vector<int> &level,
vector<int> &parent, int value) {
int minBefore = 99999999;
while (from != to) {
if (level[from] > level[to]) {
minBefore = min(minBefore, grid[from][parent[from]]);
from = parent[from];
} else if (level[from] < level[to]) {
minBefore = min(grid[to][parent[to]], minBefore);
to = parent[to];
} else {
minBefore = min(minBefore, grid[from][parent[from]]);
minBefore = min(grid[to][parent[to]], minBefore);
from = parent[from];
to = parent[to];
}
}
if (value == minBefore) return true;
return false;
}
int main() {
int wveroebi;
cin >> wveroebi;
vector<pair<int, int> > wiboebi;
vector<vector<int> > grid(wveroebi + 1);
vector<vector<int> > mezoblebi(wveroebi + 1);
for (int i = 0; i <= wveroebi; i++) {
for (int j = 0; j <= wveroebi; j++) {
grid[i].push_back(1);
}
}
for (int i = 0; i < wveroebi - 1; i++) {
int from, to;
cin >> from >> to;
wiboebi.push_back({from, to});
mezoblebi[to].push_back(from);
mezoblebi[from].push_back(to);
}
int q;
cin >> q;
vector<pair<pair<int, int>, int> > saboloo(q);
for (int i = 0; i < q; i++) {
int from, to, wona;
cin >> from >> to >> wona;
saboloo[i] = {{from, to}, wona};
}
vector<int> parents(wveroebi + 1, 1);
vector<int> level(wveroebi + 1, 1);
createTree(parents, level, mezoblebi);
for (int i = 0; i < q; i++) {
int from = saboloo[i].first.first;
int to = saboloo[i].first.second;
int value = saboloo[i].second;
makeEdge(grid, from, to, level, parents, value);
}
bool flag = true;
for (int i = 0; i < q; i++) {
int from = saboloo[i].first.first;
int to = saboloo[i].first.second;
int value = saboloo[i].second;
if (!check(grid, from, to, level, parents, value)) {
flag = false;
break;
}
}
if (!flag) {
cout << -1;
} else {
for (int i = 0; i < wveroebi - 1; i++) {
int from = wiboebi[i].first;
int to = wiboebi[i].second;
cout << grid[from][to] << " ";
}
}
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
<image>
Input
The input consists of four lines, each line containing a single digit 0 or 1.
Output
Output a single digit, 0 or 1.
Example
Input
0
1
1
0
Output
0
### Response
```cpp
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
namespace Xrocks {}
using namespace Xrocks;
namespace Xrocks {
class in {
} user_input;
class out {
} output;
in& operator>>(in& X, int& Y) {
scanf("%d", &Y);
return X;
}
in& operator>>(in& X, char* Y) {
scanf("%s", Y);
return X;
}
in& operator>>(in& X, float& Y) {
scanf("%f", &Y);
return X;
}
in& operator>>(in& X, double& Y) {
scanf("%lf", &Y);
return X;
}
in& operator>>(in& X, char& C) {
scanf("%c", &C);
return X;
}
in& operator>>(in& X, string& Y) {
cin >> Y;
return X;
}
in& operator>>(in& X, long long& Y) {
scanf("%lld", &Y);
return X;
}
template <typename T>
in& operator>>(in& X, vector<T>& Y) {
for (auto& x : Y) user_input >> x;
return X;
}
template <typename T>
out& operator<<(out& X, T Y) {
cout << Y;
return X;
}
template <typename T>
out& operator<<(out& X, vector<T>& Y) {
for (auto& x : Y) output << x << " ";
return X;
}
out& operator<<(out& X, const int& Y) {
printf("%d", Y);
return X;
}
out& operator<<(out& X, const char& C) {
printf("%c", C);
return X;
}
out& operator<<(out& X, const string& Y) {
printf("%s", Y.c_str());
return X;
}
out& operator<<(out& X, const long long& Y) {
printf("%lld", Y);
return X;
}
out& operator<<(out& X, const float& Y) {
printf("%f", Y);
return X;
}
out& operator<<(out& X, const double& Y) {
printf("%lf", Y);
return X;
}
out& operator<<(out& X, const char Y[]) {
printf("%s", Y);
return X;
}
template <typename T>
T max(T A) {
return A;
}
template <typename T, typename... args>
T max(T A, T B, args... S) {
return max(A > B ? A : B, S...);
}
template <typename T>
T min(T A) {
return A;
}
template <typename T, typename... args>
T min(T A, T B, args... S) {
return min(A < B ? A : B, S...);
}
template <typename T>
void vectorize(int y, vector<T>& A) {
A.resize(y);
}
template <typename T, typename... args>
void vectorize(int y, vector<T>& A, args&&... S) {
A.resize(y);
vectorize(y, S...);
}
long long fast(long long a, long long b, long long pr) {
if (b == 0) return 1 % pr;
long long ans = 1 % pr;
while (b) {
if (b & 1) ans = (ans * a) % pr;
b >>= 1;
a = (a * a) % pr;
}
return ans;
}
int readInt() {
int n = 0;
scanf("%d", &n);
return n;
int ch = getchar_unlocked();
int sign = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') sign = -1;
ch = getchar_unlocked();
}
while (ch >= '0' && ch <= '9')
n = (n << 3) + (n << 1) + ch - '0', ch = getchar_unlocked();
n = n * sign;
return n;
}
long long readLong() {
long long n = 0;
int ch = getchar_unlocked();
int sign = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') sign = -1;
ch = getchar_unlocked();
}
while (ch >= '0' && ch <= '9')
n = (n << 3) + (n << 1) + ch - '0', ch = getchar_unlocked();
n = n * sign;
return n;
}
long long inv_(long long val,
long long pr = static_cast<long long>(163577857)) {
return fast(val, pr - 2, pr);
}
} // namespace Xrocks
int op1(int a, int b) { return a | b; }
int op2(int a, int b) { return a & b; }
int op3(int a, int b) { return a ^ b; }
class solve {
public:
solve() {
vector<int (*)(int, int)> g = {op1, op2, op3};
vector<int> v{0, 1, 2};
vector<int> w(4);
user_input >> w;
int x = 0;
do {
vector<int (*)(int, int)> f = g;
for (int i = 0; i < 3; i++) f[i] = g[v[i]];
if (x == 5)
output << f[0](f[1](f[0](w[0], w[1]), f[2](w[2], w[3])),
f[2](f[1](w[1], w[2]), f[0](w[3], w[0])))
<< "\n";
++x;
} while (next_permutation(v.begin(), v.end()));
}
};
int32_t main() {
int t = 1, i = 1;
if (0) scanf("%d", &t);
while (t--) {
if (0) printf("Case #%d: ", i++);
new solve;
}
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
Iroha is very particular about numbers. There are K digits that she dislikes: D_1, D_2, ..., D_K.
She is shopping, and now paying at the cashier. Her total is N yen (the currency of Japan), thus she has to hand at least N yen to the cashier (and possibly receive the change).
However, as mentioned before, she is very particular about numbers. When she hands money to the cashier, the decimal notation of the amount must not contain any digits that she dislikes. Under this condition, she will hand the minimum amount of money.
Find the amount of money that she will hand to the cashier.
Constraints
* 1 ≦ N < 10000
* 1 ≦ K < 10
* 0 ≦ D_1 < D_2 < … < D_K≦9
* \\{D_1,D_2,...,D_K\\} ≠ \\{1,2,3,4,5,6,7,8,9\\}
Input
The input is given from Standard Input in the following format:
N K
D_1 D_2 … D_K
Output
Print the amount of money that Iroha will hand to the cashier.
Examples
Input
1000 8
1 3 4 5 6 7 8 9
Output
2000
Input
9999 1
0
Output
9999
### Response
```cpp
#include <bits/stdc++.h>
#define ll long long
#define PII pair < int, int >
#define x first
#define y second
using namespace std;
int n, k, a[10], u = 1;
int main(){
ios_base::sync_with_stdio(0); cin.tie(0);
cin >> n >> k;
for (int i = 1, x; i <= k; i++) cin >> x, a[x] = 1;
while (1){
int x = n;
u = 1;
while (x){
if (a[x%10]) u = 0;
x /= 10;
}
if (u) return cout << n, 0;
n++;
}
}
``` |
### Prompt
Create a solution in CPP for the following problem:
Little Petya was given this problem for homework:
You are given function <image> (here <image> represents the operation of taking the remainder). His task is to count the number of integers x in range [a;b] with property f(x) = x.
It is a pity that Petya forgot the order in which the remainders should be taken and wrote down only 4 numbers. Each of 24 possible orders of taking the remainder has equal probability of being chosen. For example, if Petya has numbers 1, 2, 3, 4 then he can take remainders in that order or first take remainder modulo 4, then modulo 2, 3, 1. There also are 22 other permutations of these numbers that represent orders in which remainder can be taken. In this problem 4 numbers wrote down by Petya will be pairwise distinct.
Now it is impossible for Petya to complete the task given by teacher but just for fun he decided to find the number of integers <image> with property that probability that f(x) = x is not less than 31.4159265352718281828459045%. In other words, Petya will pick up the number x if there exist at least 7 permutations of numbers p1, p2, p3, p4, for which f(x) = x.
Input
First line of the input will contain 6 integers, separated by spaces: p1, p2, p3, p4, a, b (1 ≤ p1, p2, p3, p4 ≤ 1000, 0 ≤ a ≤ b ≤ 31415).
It is guaranteed that numbers p1, p2, p3, p4 will be pairwise distinct.
Output
Output the number of integers in the given range that have the given property.
Examples
Input
2 7 1 8 2 8
Output
0
Input
20 30 40 50 0 100
Output
20
Input
31 41 59 26 17 43
Output
9
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int m, temp, a, b, counter = 0;
cin >> m;
cin >> temp;
m = min(m, temp);
cin >> temp;
m = min(m, temp);
cin >> temp;
m = min(m, temp);
cin >> a >> b;
for (int i = a; i <= b; i++)
if (i < m) counter++;
cout << counter << endl;
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
In the Ancient Kingdom of Snuke, there was a pyramid to strengthen the authority of Takahashi, the president of AtCoder Inc.
The pyramid had center coordinates (C_X, C_Y) and height H. The altitude of coordinates (X, Y) is max(H - |X - C_X| - |Y - C_Y|, 0).
Aoki, an explorer, conducted a survey to identify the center coordinates and height of this pyramid. As a result, he obtained the following information:
* C_X, C_Y was integers between 0 and 100 (inclusive), and H was an integer not less than 1.
* Additionally, he obtained N pieces of information. The i-th of them is: "the altitude of point (x_i, y_i) is h_i."
This was enough to identify the center coordinates and the height of the pyramid. Find these values with the clues above.
Constraints
* N is an integer between 1 and 100 (inclusive).
* x_i and y_i are integers between 0 and 100 (inclusive).
* h_i is an integer between 0 and 10^9 (inclusive).
* The N coordinates (x_1, y_1), (x_2, y_2), (x_3, y_3), ..., (x_N, y_N) are all different.
* The center coordinates and the height of the pyramid can be uniquely identified.
Input
Input is given from Standard Input in the following format:
N
x_1 y_1 h_1
x_2 y_2 h_2
x_3 y_3 h_3
:
x_N y_N h_N
Output
Print values C_X, C_Y and H representing the center coordinates and the height of the pyramid in one line, with spaces in between.
Examples
Input
4
2 3 5
2 1 5
1 2 5
3 2 5
Output
2 2 6
Input
2
0 0 100
1 1 98
Output
0 0 100
Input
3
99 1 191
100 1 192
99 0 192
Output
100 0 193
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
int main(){
ll n;
cin>>n;
ll X[n], Y[n], H[n];
vector<tuple<ll, ll, ll>> vec(n);
tuple<ll, ll, ll> g = make_tuple(-1, -1, -1);
for(ll i=0;i<n;i++){
cin>>X[i] >>Y[i] >>H[i];
if(H[i]>0)g = make_tuple(X[i], Y[i], H[i]);
}
for(ll x=0;x<=100;x++)for(ll y=0;y<=100;y++){
ll h = max(get<2>(g) + abs(get<0>(g) - x) + abs(get<1>(g) - y), 0ll);
bool ok = true;
for(ll i=0;i<n;i++){
ll hi = max(h - abs(X[i]-x) - abs(Y[i]-y), 0ll);
if(H[i]!=hi)ok=false;
}
if(ok){
cout<<x<<" "<<y<<" "<<h<<endl;
return 0;
}
}
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
You are given a graph with 3 ⋅ n vertices and m edges. You are to find a matching of n edges, or an independent set of n vertices.
A set of edges is called a matching if no two edges share an endpoint.
A set of vertices is called an independent set if no two vertices are connected with an edge.
Input
The first line contains a single integer T ≥ 1 — the number of graphs you need to process. The description of T graphs follows.
The first line of description of a single graph contains two integers n and m, where 3 ⋅ n is the number of vertices, and m is the number of edges in the graph (1 ≤ n ≤ 10^{5}, 0 ≤ m ≤ 5 ⋅ 10^{5}).
Each of the next m lines contains two integers v_i and u_i (1 ≤ v_i, u_i ≤ 3 ⋅ n), meaning that there is an edge between vertices v_i and u_i.
It is guaranteed that there are no self-loops and no multiple edges in the graph.
It is guaranteed that the sum of all n over all graphs in a single test does not exceed 10^{5}, and the sum of all m over all graphs in a single test does not exceed 5 ⋅ 10^{5}.
Output
Print your answer for each of the T graphs. Output your answer for a single graph in the following format.
If you found a matching of size n, on the first line print "Matching" (without quotes), and on the second line print n integers — the indices of the edges in the matching. The edges are numbered from 1 to m in the input order.
If you found an independent set of size n, on the first line print "IndSet" (without quotes), and on the second line print n integers — the indices of the vertices in the independent set.
If there is no matching and no independent set of the specified size, print "Impossible" (without quotes).
You can print edges and vertices in any order.
If there are several solutions, print any. In particular, if there are both a matching of size n, and an independent set of size n, then you should print exactly one of such matchings or exactly one of such independent sets.
Example
Input
4
1 2
1 3
1 2
1 2
1 3
1 2
2 5
1 2
3 1
1 4
5 1
1 6
2 15
1 2
1 3
1 4
1 5
1 6
2 3
2 4
2 5
2 6
3 4
3 5
3 6
4 5
4 6
5 6
Output
Matching
2
IndSet
1
IndSet
2 4
Matching
1 15
Note
The first two graphs are same, and there are both a matching of size 1 and an independent set of size 1. Any of these matchings and independent sets is a correct answer.
The third graph does not have a matching of size 2, however, there is an independent set of size 2. Moreover, there is an independent set of size 5: 2 3 4 5 6. However such answer is not correct, because you are asked to find an independent set (or matching) of size exactly n.
The fourth graph does not have an independent set of size 2, but there is a matching of size 2.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
long long n, m;
cin >> n >> m;
vector<long long> vis(3 * n + 1);
vector<long long> mat;
vector<long long> st;
for (long long i = 0; i < m; i++) {
long long u, v;
cin >> u >> v;
if (!vis[u] && !vis[v]) {
vis[u]++, vis[v]++;
mat.push_back(i + 1);
}
}
for (long long i = 1; i < 3 * n + 1; i++) {
if (!vis[i]) st.push_back(i);
}
if (mat.size() >= n) {
cout << "Matching\n";
for (long long i = 0; i < n; i++) cout << mat[i] << " ";
} else if (st.size() >= n) {
cout << "IndSet\n";
for (long long i = 0; i < n; i++) cout << st[i] << " ";
} else {
cout << "Impossible";
}
cout << "\n";
}
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
Quick sort is based on the Divide-and-conquer approach. In QuickSort(A, p, r), first, a procedure Partition(A, p, r) divides an array A[p..r] into two subarrays A[p..q-1] and A[q+1..r] such that each element of A[p..q-1] is less than or equal to A[q], which is, inturn, less than or equal to each element of A[q+1..r]. It also computes the index q.
In the conquer processes, the two subarrays A[p..q-1] and A[q+1..r] are sorted by recursive calls of QuickSort(A, p, q-1) and QuickSort(A, q+1, r).
Your task is to read a sequence A and perform the Partition based on the following pseudocode:
Partition(A, p, r)
1 x = A[r]
2 i = p-1
3 for j = p to r-1
4 do if A[j] <= x
5 then i = i+1
6 exchange A[i] and A[j]
7 exchange A[i+1] and A[r]
8 return i+1
Note that, in this algorithm, Partition always selects an element A[r] as a pivot element around which to partition the array A[p..r].
Constraints
* 1 ≤ n ≤ 100,000
* 0 ≤ Ai ≤ 100,000
Input
The first line of the input includes an integer n, the number of elements in the sequence A.
In the second line, Ai (i = 1,2,...,n), elements of the sequence are given separated by space characters.
Output
Print the sorted sequence. Two contiguous elements of the sequence should be separated by a space character. The element which is selected as the pivot of the partition should be indicated by [ ].
Example
Input
12
13 19 9 5 12 8 7 4 21 2 6 11
Output
9 5 8 7 4 2 6 [11] 21 13 19 12
### Response
```cpp
#include <iostream>
#include <cstdio>
using namespace std;
int partition(int A[],int p,int r){
int x = A[r];
int i = p-1;
for(int j=p;j<r;j++){
if(A[j]<=x){
i++;
swap(A[j],A[i]);
}
}
swap(A[i+1],A[r]);
return i+1;
}
int main(){
int n;cin>>n;
int A[n];
for(int i=0;i<n;i++){
cin>>A[i];
}
int pibot = partition(A,0,n-1);
for(int i=0;i<n;i++){
if(i) printf(" ");
if(i==pibot){
printf("[%d]",A[i]);
}else{
printf("%d",A[i]);
}
}
printf("\n");
}
``` |
### Prompt
Generate a cpp solution to the following problem:
Iahub and Sorin are the best competitive programmers in their town. However, they can't both qualify to an important contest. The selection will be made with the help of a single problem. Blatnatalag, a friend of Iahub, managed to get hold of the problem before the contest. Because he wants to make sure Iahub will be the one qualified, he tells Iahub the following task.
You're given an (1-based) array a with n elements. Let's define function f(i, j) (1 ≤ i, j ≤ n) as (i - j)2 + g(i, j)2. Function g is calculated by the following pseudo-code:
int g(int i, int j) {
int sum = 0;
for (int k = min(i, j) + 1; k <= max(i, j); k = k + 1)
sum = sum + a[k];
return sum;
}
Find a value mini ≠ j f(i, j).
Probably by now Iahub already figured out the solution to this problem. Can you?
Input
The first line of input contains a single integer n (2 ≤ n ≤ 100000). Next line contains n integers a[1], a[2], ..., a[n] ( - 104 ≤ a[i] ≤ 104).
Output
Output a single integer — the value of mini ≠ j f(i, j).
Examples
Input
4
1 0 0 -1
Output
1
Input
2
1 -1
Output
2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1);
struct Point {
int x;
int y;
void CO() { cout << x << ' ' << y << endl; }
};
Point T[100100], tg[100100];
int n;
long long res;
bool cmp(Point a, Point b) { return (a.y < b.y); }
long long Dis(Point a, Point b) {
return ((long long)a.x - b.x) * (a.x - b.x) +
((long long)a.y - b.y) * (a.y - b.y);
}
void Cal(int left, int right) {
if (left == right) return;
int mid = (left + right) / 2;
Cal(left, mid);
Cal(mid + 1, right);
int dem = 0, i = left, j = mid + 1;
while (i <= mid && j <= right)
if (T[i].x < T[j].x)
tg[++dem] = T[i++];
else
tg[++dem] = T[j++];
while (i <= mid) tg[++dem] = T[i++];
while (j <= right) tg[++dem] = T[j++];
for (int u = left; u <= right; u++) T[u] = tg[u - left + 1];
for (int u = left; u <= right; u++)
for (int v = max(left, u - 5); v <= u - 1; v++) {
res = min(res, Dis(T[u], T[v]));
}
}
int main() {
scanf("%d", &n);
int sum = 0;
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
sum += x;
T[i].x = i;
T[i].y = sum;
}
res = 2000000000000000000;
sort(T + 1, T + n + 1, cmp);
Cal(1, n);
cout << res;
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
You are given four integers A, B, C, and D. Find the number of integers between A and B (inclusive) that can be evenly divided by neither C nor D.
Constraints
* 1\leq A\leq B\leq 10^{18}
* 1\leq C,D\leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
A B C D
Output
Print the number of integers between A and B (inclusive) that can be evenly divided by neither C nor D.
Examples
Input
4 9 2 3
Output
2
Input
10 40 6 8
Output
23
Input
314159265358979323 846264338327950288 419716939 937510582
Output
532105071133627368
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int g(int c,int d){
if(c>d)
return g(d,c);
if(c==0)
return d;
return g(d%c,c);
}
int main(){
int64_t a,b,c,d;
cin>>a>>b>>c>>d;
a--;
int64_t l=c*d/g(c,d);
cout<<(b-b/c-b/d+b/l)-(a-a/c-a/d+a/l)<<endl;
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
The Smart Beaver from ABBYY was offered a job of a screenwriter for the ongoing TV series. In particular, he needs to automate the hard decision: which main characters will get married by the end of the series.
There are n single men and n single women among the main characters. An opinion poll showed that viewers like several couples, and a marriage of any of them will make the audience happy. The Smart Beaver formalized this fact as k triples of numbers (h, w, r), where h is the index of the man, w is the index of the woman, and r is the measure of the audience's delight in case of the marriage of this couple. The same poll showed that the marriage of any other couple will leave the audience indifferent, so the screenwriters decided not to include any such marriages in the plot.
The script allows you to arrange several marriages between the heroes or not to arrange marriages at all. A subset of some of the k marriages is considered acceptable if each man and each woman is involved in at most one marriage of the subset (the series won't allow any divorces). The value of the acceptable set of marriages is the total delight the spectators will get from the marriages included in this set.
Obviously, there is a finite number of acceptable sets, and they all describe some variants of the script. The screenwriters do not want to choose a set with maximum value — it would make the plot too predictable. So the Smart Beaver offers the following option: sort all the acceptable sets in increasing order of value and choose the t-th set from the sorted list. Thus, t = 1 corresponds to a plot without marriages, t = 2 — to a single marriage resulting in minimal delight for the audience, and so on.
Help the Beaver to implement the algorithm for selecting the desired set.
Input
The first input line contains integers n, k and t (1 ≤ k ≤ min(100, n2), 1 ≤ t ≤ 2·105), separated by single spaces. Next k lines contain triples of integers (h, w, r) (1 ≤ h, w ≤ n; 1 ≤ r ≤ 1000), separated by single spaces, which describe the possible marriages. It is guaranteed that the input data is correct: t doesn't exceed the total number of acceptable sets, and each pair (h, w) is present in at most one triple.
The input limitations for getting 30 points are:
* 1 ≤ n ≤ 5
The input limitations for getting 100 points are:
* 1 ≤ n ≤ 20
Output
Print a single number — the value of the t-th acceptable variant.
Examples
Input
2 4 3
1 1 1
1 2 2
2 1 3
2 2 7
Output
2
Input
2 4 7
1 1 1
1 2 2
2 1 3
2 2 7
Output
8
Note
The figure shows 7 acceptable sets of marriages that exist in the first sample.
<image>
### Response
```cpp
#include <bits/stdc++.h>
int value[21][21];
int yes[21][21];
int hash[21];
int seq[1 << 21], tot = 0;
int N, M, K;
void dfs(int x, int count) {
int i, j;
if (x <= N) {
dfs(x + 1, count);
for (i = 1; i <= N; ++i)
if (hash[i] == 0 && yes[x][i] == 1) {
hash[i] = 1;
dfs(x + 1, count + value[x][i]);
hash[i] = 0;
}
} else {
seq[++tot] = count;
}
}
int main() {
int i, j, sc, sv, t;
scanf("%d%d%d", &N, &M, &K);
for (i = 1; i <= M; ++i) {
scanf("%d%d%d", &sc, &sv, &t);
value[sc][sv] = t;
yes[sc][sv] = 1;
}
dfs(1, 0);
std::sort(seq + 1, seq + tot + 1);
printf("%d\n", seq[K]);
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
Find the number of integers between 1 and K (inclusive) satisfying the following condition, modulo 10^9 + 7:
* The sum of the digits in base ten is a multiple of D.
Constraints
* All values in input are integers.
* 1 \leq K < 10^{10000}
* 1 \leq D \leq 100
Input
Input is given from Standard Input in the following format:
K
D
Output
Print the number of integers satisfying the condition, modulo 10^9 + 7.
Examples
Input
30
4
Output
6
Input
1000000009
1
Output
2
Input
98765432109876543210
58
Output
635270834
### Response
```cpp
#include <bits/stdc++.h>
const long long mo=1000000000+7;
std::string K;
int D;
long long dp[2][100][10001];//1:strict
int main(){
std::cin >> K;
std::cin >> D;
dp[1][0][0]=1;
for(int i=0;i<(int)(K.length());++i){
for(int k=0;k<D;++k){
for(int j=0;j<=9;++j){
int nk=(j+k)%D;
dp[0][nk][i+1]+=dp[0][k][i];
dp[0][nk][i+1]%=mo;
}
for(int j=0;j<(int)(K[i]-'0');++j){
int nk=(j+k)%D;
dp[0][nk][i+1]+=dp[1][k][i];
dp[0][nk][i+1]%=mo;
}
int nk=(k+(int)(K[i]-'0'))%D;
dp[1][nk][i+1]+=dp[1][k][i];
dp[1][nk][i+1]%=mo;
}
}
std::cout<<(dp[0][0][(int)(K.length())]+dp[1][0][(int)(K.length())]+mo-1)%mo<<std::endl;
return 0;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
Arcady is a copywriter. His today's task is to type up an already well-designed story using his favorite text editor.
Arcady types words, punctuation signs and spaces one after another. Each letter and each sign (including line feed) requires one keyboard click in order to be printed. Moreover, when Arcady has a non-empty prefix of some word on the screen, the editor proposes a possible autocompletion for this word, more precisely one of the already printed words such that its prefix matches the currently printed prefix if this word is unique. For example, if Arcady has already printed «codeforces», «coding» and «codeforces» once again, then there will be no autocompletion attempt for «cod», but if he proceeds with «code», the editor will propose «codeforces».
With a single click Arcady can follow the editor's proposal, i.e. to transform the current prefix to it. Note that no additional symbols are printed after the autocompletion (no spaces, line feeds, etc). What is the minimum number of keyboard clicks Arcady has to perform to print the entire text, if he is not allowed to move the cursor or erase the already printed symbols?
A word here is a contiguous sequence of latin letters bordered by spaces, punctuation signs and line/text beginnings/ends. Arcady uses only lowercase letters. For example, there are 20 words in «it's well-known that tic-tac-toe is a paper-and-pencil game for two players, x and o.».
Input
The only line contains Arcady's text, consisting only of lowercase latin letters, spaces, line feeds and the following punctuation signs: «.», «,», «?», «!», «'» and «-». The total amount of symbols doesn't exceed 3·105. It's guaranteed that all lines are non-empty.
Output
Print a single integer — the minimum number of clicks.
Examples
Input
snow affects sports such as skiing, snowboarding, and snowmachine travel.
snowboarding is a recreational activity and olympic and paralympic sport.
Output
141
Input
'co-co-co, codeforces?!'
Output
25
Input
thun-thun-thunder, thunder, thunder
thunder, thun-, thunder
thun-thun-thunder, thunder
thunder, feel the thunder
lightning then the thunder
thunder, feel the thunder
lightning then the thunder
thunder, thunder
Output
183
Note
In sample case one it's optimal to use autocompletion for the first instance of «snowboarding» after typing up «sn» and for the second instance of «snowboarding» after typing up «snowb». This will save 7 clicks.
In sample case two it doesn't matter whether to use autocompletion or not.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct nd {
int nx[26];
int p;
int c;
bool t;
nd(int pp = 0) {
for (int i = 0; i < 26; i++) {
nx[i] = -1;
}
c = 0;
t = 0;
p = pp;
}
};
vector<nd> s;
int main() {
cin >> noskipws;
char a;
int t = 0;
int ans = 0;
bool f = 0;
int fb = 0;
s.push_back(nd(-1));
s[0].p = -1;
while (cin >> a) {
ans++;
if (a < 'a' || a > 'z') {
if (s[t].t == 0) {
s[t].t = 1;
while (t != -1) {
s[t].c++;
t = s[t].p;
}
}
t = 0;
f = 0;
} else {
a -= 'a';
if (s[t].nx[a] == -1) {
s[t].nx[a] = (int)s.size();
s.push_back(nd(t));
}
t = s[t].nx[a];
if (f && s[t].c == 1) {
fb++;
}
if (s[t].c == 1 && !f) {
f = 1;
fb = 0;
}
if (f && s[t].t == 1 && fb > 0) {
ans -= fb - 1;
f = 0;
fb = 0;
}
}
}
cout << ans << '\n';
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
Two little greedy bears have found two pieces of cheese in the forest of weight a and b grams, correspondingly. The bears are so greedy that they are ready to fight for the larger piece. That's where the fox comes in and starts the dialog: "Little bears, wait a little, I want to make your pieces equal" "Come off it fox, how are you going to do that?", the curious bears asked. "It's easy", said the fox. "If the mass of a certain piece is divisible by two, then I can eat exactly a half of the piece. If the mass of a certain piece is divisible by three, then I can eat exactly two-thirds, and if the mass is divisible by five, then I can eat four-fifths. I'll eat a little here and there and make the pieces equal".
The little bears realize that the fox's proposal contains a catch. But at the same time they realize that they can not make the two pieces equal themselves. So they agreed to her proposal, but on one condition: the fox should make the pieces equal as quickly as possible. Find the minimum number of operations the fox needs to make pieces equal.
Input
The first line contains two space-separated integers a and b (1 ≤ a, b ≤ 109).
Output
If the fox is lying to the little bears and it is impossible to make the pieces equal, print -1. Otherwise, print the required minimum number of operations. If the pieces of the cheese are initially equal, the required number is 0.
Examples
Input
15 20
Output
3
Input
14 8
Output
-1
Input
6 6
Output
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
int a2 = 0, a3 = 0, a5 = 0, b2 = 0, b3 = 0, b5 = 0;
while (a % 2 == 0 || a % 3 == 0 || a % 5 == 0) {
if (a % 2 == 0) a2++, a /= 2;
if (a % 3 == 0) a3++, a /= 3;
if (a % 5 == 0) a5++, a /= 5;
}
while (b % 2 == 0 || b % 3 == 0 || b % 5 == 0) {
if (b % 2 == 0) b2++, b /= 2;
if (b % 3 == 0) b3++, b /= 3;
if (b % 5 == 0) b5++, b /= 5;
}
if (a != b)
cout << -1;
else
cout << abs(a2 - b2) + abs(a3 - b3) + abs(a5 - b5);
return 0;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
You have a string s = s1s2...s|s|, where |s| is the length of string s, and si its i-th character.
Let's introduce several definitions:
* A substring s[i..j] (1 ≤ i ≤ j ≤ |s|) of string s is string sisi + 1...sj.
* The prefix of string s of length l (1 ≤ l ≤ |s|) is string s[1..l].
* The suffix of string s of length l (1 ≤ l ≤ |s|) is string s[|s| - l + 1..|s|].
Your task is, for any prefix of string s which matches a suffix of string s, print the number of times it occurs in string s as a substring.
Input
The single line contains a sequence of characters s1s2...s|s| (1 ≤ |s| ≤ 105) — string s. The string only consists of uppercase English letters.
Output
In the first line, print integer k (0 ≤ k ≤ |s|) — the number of prefixes that match a suffix of string s. Next print k lines, in each line print two integers li ci. Numbers li ci mean that the prefix of the length li matches the suffix of length li and occurs in string s as a substring ci times. Print pairs li ci in the order of increasing li.
Examples
Input
ABACABA
Output
3
1 4
3 2
7 1
Input
AAA
Output
3
1 3
2 2
3 1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 2;
const int INF = 1e9 + 7;
vector<int> Z;
string T;
void zeta(string &U) {
Z = vector<int>(T.size(), 0);
for (int i = 1, l = 0, r = 0; i < U.size(); i++) {
if (i <= r) Z[i] = min(Z[i - l], r - i + 1);
for (; i + Z[i] < U.size() && U[Z[i]] == U[i + Z[i]]; Z[i]++)
;
if (r < i + Z[i] - 1) l = i, r = i + Z[i] - 1;
}
Z[0] = T.size();
}
int cnt[N];
bool isPreff[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> T;
zeta(T);
int n = T.size();
for (int i = 0; i < n; i++) {
if (i + Z[i] == n) {
isPreff[Z[i]] = true;
}
cnt[1]++;
cnt[Z[i] + 1]--;
}
int sum = 0;
vector<pair<int, int> > ans;
for (int i = 1; i <= n; i++) {
sum += cnt[i];
if (!isPreff[i]) continue;
ans.push_back({i, sum});
}
cout << ans.size() << '\n';
for (pair<int, int> p : ans) {
cout << p.first << ' ' << p.second << '\n';
}
return 0;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
Mislove had an array a_1, a_2, ⋅⋅⋅, a_n of n positive integers, but he has lost it. He only remembers the following facts about it:
* The number of different numbers in the array is not less than l and is not greater than r;
* For each array's element a_i either a_i = 1 or a_i is even and there is a number (a_i)/(2) in the array.
For example, if n=5, l=2, r=3 then an array could be [1,2,2,4,4] or [1,1,1,1,2]; but it couldn't be [1,2,2,4,8] because this array contains 4 different numbers; it couldn't be [1,2,2,3,3] because 3 is odd and isn't equal to 1; and it couldn't be [1,1,2,2,16] because there is a number 16 in the array but there isn't a number 16/2 = 8.
According to these facts, he is asking you to count the minimal and the maximal possible sums of all elements in an array.
Input
The only input line contains three integers n, l and r (1 ≤ n ≤ 1 000, 1 ≤ l ≤ r ≤ min(n, 20)) — an array's size, the minimal number and the maximal number of distinct elements in an array.
Output
Output two numbers — the minimal and the maximal possible sums of all elements in an array.
Examples
Input
4 2 2
Output
5 7
Input
5 1 5
Output
5 31
Note
In the first example, an array could be the one of the following: [1,1,1,2], [1,1,2,2] or [1,2,2,2]. In the first case the minimal sum is reached and in the last case the maximal sum is reached.
In the second example, the minimal sum is reached at the array [1,1,1,1,1], and the maximal one is reached at the array [1,2,4,8,16].
### Response
```cpp
#include <bits/stdc++.h>
int main() {
int n, l, r, s, c = 1, min = 0, max = 1, i;
scanf("%d%d%d", &n, &l, &r);
s = l - 1;
for (i = 1; i <= s; i++) {
c *= 2;
min += c;
}
min += (n - s);
c = 1;
for (i = 1; i < r; i++) {
c *= 2;
max += c;
}
for (i = 1; i <= n - r; i++) {
max += c;
}
printf("%d ", min);
printf("%d\n", max);
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
The Free Meteor Association (FMA) has got a problem: as meteors are moving, the Universal Cosmic Descriptive Humorous Program (UCDHP) needs to add a special module that would analyze this movement.
UCDHP stores some secret information about meteors as an n × m table with integers in its cells. The order of meteors in the Universe is changing. That's why the main UCDHP module receives the following queries:
* The query to swap two table rows;
* The query to swap two table columns;
* The query to obtain a secret number in a particular table cell.
As the main UCDHP module is critical, writing the functional of working with the table has been commissioned to you.
Input
The first line contains three space-separated integers n, m and k (1 ≤ n, m ≤ 1000, 1 ≤ k ≤ 500000) — the number of table columns and rows and the number of queries, correspondingly.
Next n lines contain m space-separated numbers each — the initial state of the table. Each number p in the table is an integer and satisfies the inequality 0 ≤ p ≤ 106.
Next k lines contain queries in the format "si xi yi", where si is one of the characters "с", "r" or "g", and xi, yi are two integers.
* If si = "c", then the current query is the query to swap columns with indexes xi and yi (1 ≤ x, y ≤ m, x ≠ y);
* If si = "r", then the current query is the query to swap rows with indexes xi and yi (1 ≤ x, y ≤ n, x ≠ y);
* If si = "g", then the current query is the query to obtain the number that located in the xi-th row and in the yi-th column (1 ≤ x ≤ n, 1 ≤ y ≤ m).
The table rows are considered to be indexed from top to bottom from 1 to n, and the table columns — from left to right from 1 to m.
Output
For each query to obtain a number (si = "g") print the required number. Print the answers to the queries in the order of the queries in the input.
Examples
Input
3 3 5
1 2 3
4 5 6
7 8 9
g 3 2
r 3 2
c 2 3
g 2 2
g 3 2
Output
8
9
6
Input
2 3 3
1 2 4
3 1 5
c 2 1
r 1 2
g 1 3
Output
5
Note
Let's see how the table changes in the second test case.
After the first operation is fulfilled, the table looks like that:
2 1 4
1 3 5
After the second operation is fulfilled, the table looks like that:
1 3 5
2 1 4
So the answer to the third query (the number located in the first row and in the third column) will be 5.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int a[1005][1005];
int h[1005];
int l[1005];
int main() {
int n, m, i, j, k, p, q, t;
char str[3], cc;
while (scanf("%d%d%d", &n, &m, &k) != EOF) {
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) scanf("%d", &a[i][j]);
for (i = 1; i <= n; i++) h[i] = i;
for (j = 1; j <= m; j++) l[j] = j;
cc = getchar();
for (i = 0; i < k; i++) {
scanf("%s", &str);
scanf("%d%d", &p, &q);
cc = getchar();
if (str[0] == 'g') printf("%d\n", a[h[p]][l[q]]);
if (p == q) continue;
if (str[0] == 'r') {
t = h[p];
h[p] = h[q];
h[q] = t;
} else if (str[0] == 'c') {
t = l[p];
l[p] = l[q];
l[q] = t;
}
}
}
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
Alice and Bob are playing a game on a line with n cells. There are n cells labeled from 1 through n. For each i from 1 to n-1, cells i and i+1 are adjacent.
Alice initially has a token on some cell on the line, and Bob tries to guess where it is.
Bob guesses a sequence of line cell numbers x_1, x_2, …, x_k in order. In the i-th question, Bob asks Alice if her token is currently on cell x_i. That is, Alice can answer either "YES" or "NO" to each Bob's question.
At most one time in this process, before or after answering a question, Alice is allowed to move her token from her current cell to some adjacent cell. Alice acted in such a way that she was able to answer "NO" to all of Bob's questions.
Note that Alice can even move her token before answering the first question or after answering the last question. Alice can also choose to not move at all.
You are given n and Bob's questions x_1, …, x_k. You would like to count the number of scenarios that let Alice answer "NO" to all of Bob's questions.
Let (a,b) denote a scenario where Alice starts at cell a and ends at cell b. Two scenarios (a_i, b_i) and (a_j, b_j) are different if a_i ≠ a_j or b_i ≠ b_j.
Input
The first line contains two integers n and k (1 ≤ n,k ≤ 10^5) — the number of cells and the number of questions Bob asked.
The second line contains k integers x_1, x_2, …, x_k (1 ≤ x_i ≤ n) — Bob's questions.
Output
Print a single integer, the number of scenarios that let Alice answer "NO" to all of Bob's questions.
Examples
Input
5 3
5 1 4
Output
9
Input
4 8
1 2 3 4 4 3 2 1
Output
0
Input
100000 1
42
Output
299997
Note
The notation (i,j) denotes a scenario where Alice starts at cell i and ends at cell j.
In the first example, the valid scenarios are (1, 2), (2, 1), (2, 2), (2, 3), (3, 2), (3, 3), (3, 4), (4, 3), (4, 5). For example, (3,4) is valid since Alice can start at cell 3, stay there for the first three questions, then move to cell 4 after the last question.
(4,5) is valid since Alice can start at cell 4, stay there for the first question, the move to cell 5 for the next two questions. Note that (4,5) is only counted once, even though there are different questions that Alice can choose to do the move, but remember, we only count each pair of starting and ending positions once.
In the second example, Alice has no valid scenarios.
In the last example, all (i,j) where |i-j| ≤ 1 except for (42, 42) are valid scenarios.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int INF = 0x3f3f3f3f;
int a[100100];
int id[100010];
int vis[100010];
int ans1[100100];
int ans2[100100];
int main() {
long long n, k, kk = 0;
scanf("%lld%lld", &n, &k);
for (int i = 1; i <= k; i++) {
scanf("%d", &id[i]);
if (a[id[i]] == 0) a[id[i]] = 1, kk++;
}
long long ans = n + (n - 1) * 2;
ans -= kk;
for (int i = 1; i <= k; i++) {
if (vis[id[i] + 1] == 1 && id[i] + 1 <= n) ans1[id[i] + 1] = 1;
if (vis[id[i] - 1] == 1 && id[i] - 1 >= 1) ans2[id[i] - 1] = 1;
vis[id[i]] = 1;
}
for (int i = 1; i <= n; i++)
if (ans1[i] == 1) ans--;
for (int i = 1; i <= n; i++)
if (ans2[i] == 1) ans--;
printf("%lld\n", ans);
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
Ehab is interested in the bitwise-xor operation and the special graphs. Mahmoud gave him a problem that combines both. He has a complete graph consisting of n vertices numbered from 0 to n - 1. For all 0 ≤ u < v < n, vertex u and vertex v are connected with an undirected edge that has weight <image> (where <image> is the [bitwise-xor operation](https://en.wikipedia.org/wiki/Bitwise_operation#XOR)). Can you find the weight of the minimum spanning tree of that graph?
You can read about complete graphs in <https://en.wikipedia.org/wiki/Complete_graph>
You can read about the minimum spanning tree in <https://en.wikipedia.org/wiki/Minimum_spanning_tree>
The weight of the minimum spanning tree is the sum of the weights on the edges included in it.
Input
The only line contains an integer n (2 ≤ n ≤ 1012), the number of vertices in the graph.
Output
The only line contains an integer x, the weight of the graph's minimum spanning tree.
Example
Input
4
Output
4
Note
In the first sample: <image> The weight of the minimum spanning tree is 1+2+1=4.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int64_t n;
cin >> n;
n--;
auto f = [&](int64_t x) { return (n - x) / (x << 1) + 1; };
int64_t res = 0;
for (int64_t i = 1; i <= n; i <<= 1) {
res += (f(i) * i);
}
cout << res << '\n';
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
Kris works in a large company "Blake Technologies". As a best engineer of the company he was assigned a task to develop a printer that will be able to print horizontal and vertical strips. First prototype is already built and Kris wants to tests it. He wants you to implement the program that checks the result of the printing.
Printer works with a rectangular sheet of paper of size n × m. Consider the list as a table consisting of n rows and m columns. Rows are numbered from top to bottom with integers from 1 to n, while columns are numbered from left to right with integers from 1 to m. Initially, all cells are painted in color 0.
Your program has to support two operations:
1. Paint all cells in row ri in color ai;
2. Paint all cells in column ci in color ai.
If during some operation i there is a cell that have already been painted, the color of this cell also changes to ai.
Your program has to print the resulting table after k operation.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 5000, n·m ≤ 100 000, 1 ≤ k ≤ 100 000) — the dimensions of the sheet and the number of operations, respectively.
Each of the next k lines contains the description of exactly one query:
* 1 ri ai (1 ≤ ri ≤ n, 1 ≤ ai ≤ 109), means that row ri is painted in color ai;
* 2 ci ai (1 ≤ ci ≤ m, 1 ≤ ai ≤ 109), means that column ci is painted in color ai.
Output
Print n lines containing m integers each — the resulting table after all operations are applied.
Examples
Input
3 3 3
1 1 3
2 2 1
1 2 2
Output
3 1 3
2 2 2
0 1 0
Input
5 3 5
1 1 1
1 3 1
1 5 1
2 1 1
2 3 1
Output
1 1 1
1 0 1
1 1 1
1 0 1
1 1 1
Note
The figure below shows all three operations for the first sample step by step. The cells that were painted on the corresponding step are marked gray.
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long int n, m, k, i, j, par;
long long int a;
int ch;
cin >> n >> m >> k;
long int R[n], R1[n], C[m], C1[m];
for (i = 0; i < n; i++) {
R[i] = R1[i] = 0;
}
for (int i = 0; i < m; i++) {
C[i] = C1[i] = 0;
}
for (int i = 0; i < k; i++) {
cin >> ch >> par >> a;
if (ch == 1) {
R[par - 1] = a;
R1[par - 1] = i;
} else {
C[par - 1] = a;
C1[par - 1] = i;
}
}
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (C[j] == 0) {
cout << R[i] << " ";
} else if (R[i] == 0) {
cout << C[j] << " ";
} else {
if (C1[j] > R1[i]) {
cout << C[j] << " ";
} else {
cout << R[i] << " ";
}
}
}
cout << "\n";
}
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
Example
Input
anagram
grandmother
Output
4
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
typedef array<int, 26> Vec;
char buf[114514];
int cnt[2][114514][26];
string S[2];
vector<int> appear[2][26];
int main() {
scanf("%s", buf);
S[0] = buf;
scanf("%s", buf);
S[1] = buf;
for (int k=0; k<2; k++) {
for (int i=0; i<S[k].size(); i++) {
appear[k][S[k][i]-'a'].emplace_back(i);
if (i > 0) {
for (int j=0; j<26; j++) {
cnt[k][i][j] = cnt[k][i-1][j];
}
}
cnt[k][i][S[k][i]-'a']++;
}
}
int t = (int)min(S[0].size(), S[1].size());
for (int k=t; k>=1; k--) {
vector<Vec> vs;
for (int i=0; i+k<=S[0].size(); i++) {
Vec v;
for (int j=0; j<26; j++) {
v[j] = cnt[0][i+k-1][j];
if (i > 0) v[j] -= cnt[0][i-1][j];
}
vs.emplace_back(v);
}
sort(vs.begin(), vs.end());
for (int i=0; i+k<=S[1].size(); i++) {
Vec v;
for (int j=0; j<26; j++) {
v[j] = cnt[1][i+k-1][j];
if (i > 0) v[j] -= cnt[1][i-1][j];
}
if (binary_search(vs.begin(), vs.end(), v)) {
printf("%d\n", k);
return 0;
}
}
}
puts("0");
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
You are given an array of n elements, you must make it a co-prime array in as few moves as possible.
In each move you can insert any positive integral number you want not greater than 109 in any place in the array.
An array is co-prime if any two adjacent numbers of it are co-prime.
In the number theory, two integers a and b are said to be co-prime if the only positive integer that divides both of them is 1.
Input
The first line contains integer n (1 ≤ n ≤ 1000) — the number of elements in the given array.
The second line contains n integers ai (1 ≤ ai ≤ 109) — the elements of the array a.
Output
Print integer k on the first line — the least number of elements needed to add to the array a to make it co-prime.
The second line should contain n + k integers aj — the elements of the array a after adding k elements to it. Note that the new array should be co-prime, so any two adjacent values should be co-prime. Also the new array should be got from the original array a by adding k elements to it.
If there are multiple answers you can print any one of them.
Example
Input
3
2 7 28
Output
1
2 7 9 28
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int GCD(int x, int y) { return (!x) ? y : GCD(y % x, x); }
int a[1004], N, i, c;
int main() {
for (scanf("%d", &N), i = 1; i <= N; i++) scanf("%d", &a[i]);
for (i = 1; i <= N - 1; i++) {
if (GCD(a[i], a[i + 1]) != 1) c++;
}
for (printf("%d\n%d ", c, a[1]), i = 1; i <= N - 1; i++) {
if (GCD(a[i], a[i + 1]) != 1)
printf("1 %d ", a[i + 1]);
else
printf("%d ", a[i + 1]);
}
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
A ball will bounce along a number line, making N + 1 bounces. It will make the first bounce at coordinate D_1 = 0, and the i-th bounce (2 \leq i \leq N+1) at coordinate D_i = D_{i-1} + L_{i-1}.
How many times will the ball make a bounce where the coordinate is at most X?
Constraints
* 1 \leq N \leq 100
* 1 \leq L_i \leq 100
* 1 \leq X \leq 10000
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N X
L_1 L_2 ... L_{N-1} L_N
Output
Print the number of times the ball will make a bounce where the coordinate is at most X.
Examples
Input
3 6
3 4 5
Output
2
Input
4 9
3 3 3 3
Output
4
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
int N,X,D=0,cnt = 0;
cin >> N >> X;
int l[N];
for(int i=0;i<N;i++){
cin >> l[i];
D = D + l[i];
if(D<=X)
cnt++;
}
cout << cnt+1 << endl;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
The tournament «Sleepyhead-2010» in the rapid falling asleep has just finished in Berland. n best participants from the country have participated in it. The tournament consists of games, each of them is a match between two participants. n·(n - 1) / 2 games were played during the tournament, and each participant had a match with each other participant.
The rules of the game are quite simple — the participant who falls asleep first wins. The secretary made a record of each game in the form «xi yi», where xi and yi are the numbers of participants. The first number in each pair is a winner (i.e. xi is a winner and yi is a loser). There is no draws.
Recently researches form the «Institute Of Sleep» have found that every person is characterized by a value pj — the speed of falling asleep. The person who has lower speed wins. Every person has its own value pj, constant during the life.
It is known that all participants of the tournament have distinct speeds of falling asleep. Also it was found that the secretary made records about all the games except one. You are to find the result of the missing game.
Input
The first line contains one integer n (3 ≤ n ≤ 50) — the number of participants. The following n·(n - 1) / 2 - 1 lines contain the results of the games. Each game is described in a single line by two integers xi, yi (1 ≤ xi, yi ≤ n, xi ≠ yi), where xi и yi are the numbers of the opponents in this game. It is known that during the tournament each of the n participants played n - 1 games, one game with each other participant.
Output
Output two integers x and y — the missing record. If there are several solutions, output any of them.
Examples
Input
4
4 2
4 1
2 3
2 1
3 1
Output
4 3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int apa[51], arr[51], n, x, y, xx, yy;
int main() {
scanf("%d", &n);
for (int i = 0; i < (n * (n - 1) / 2) - 1; i++) {
scanf("%d %d", &x, &y);
arr[x]++;
apa[x]++;
apa[y]++;
}
for (int i = 1; i <= n; i++)
if (apa[i] != n - 1) {
if (xx == 0)
xx = i;
else
yy = i;
}
if (arr[xx] > arr[yy])
printf("%d %d", xx, yy);
else
printf("%d %d", yy, xx);
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
There are some ambiguities when one writes Berland names with the letters of the Latin alphabet.
For example, the Berland sound u can be written in the Latin alphabet as "u", and can be written as "oo". For this reason, two words "ulyana" and "oolyana" denote the same name.
The second ambiguity is about the Berland sound h: one can use both "h" and "kh" to write it. For example, the words "mihail" and "mikhail" denote the same name.
There are n users registered on the Polycarp's website. Each of them indicated a name represented by the Latin letters. How many distinct names are there among them, if two ambiguities described above are taken into account?
Formally, we assume that two words denote the same name, if using the replacements "u" <image> "oo" and "h" <image> "kh", you can make the words equal. One can make replacements in both directions, in any of the two words an arbitrary number of times. A letter that resulted from the previous replacement can participate in the next replacements.
For example, the following pairs of words denote the same name:
* "koouper" and "kuooper". Making the replacements described above, you can make both words to be equal: "koouper" <image> "kuuper" and "kuooper" <image> "kuuper".
* "khun" and "kkkhoon". With the replacements described above you can make both words to be equal: "khun" <image> "khoon" and "kkkhoon" <image> "kkhoon" <image> "khoon".
For a given list of words, find the minimal number of groups where the words in each group denote the same name.
Input
The first line contains integer number n (2 ≤ n ≤ 400) — number of the words in the list.
The following n lines contain words, one word per line. Each word consists of only lowercase Latin letters. The length of each word is between 1 and 20 letters inclusive.
Output
Print the minimal number of groups where the words in each group denote the same name.
Examples
Input
10
mihail
oolyana
kooooper
hoon
ulyana
koouper
mikhail
khun
kuooper
kkkhoon
Output
4
Input
9
hariton
hkariton
buoi
kkkhariton
boooi
bui
khariton
boui
boi
Output
5
Input
2
alex
alex
Output
1
Note
There are four groups of words in the first example. Words in each group denote same name:
1. "mihail", "mikhail"
2. "oolyana", "ulyana"
3. "kooooper", "koouper"
4. "hoon", "khun", "kkkhoon"
There are five groups of words in the second example. Words in each group denote same name:
1. "hariton", "kkkhariton", "khariton"
2. "hkariton"
3. "buoi", "boooi", "boui"
4. "bui"
5. "boi"
In the third example the words are equal, so they denote the same name.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int k, n, m, x, ans;
int a[N];
string second, r;
map<string, int> vis1, vis2;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
char e[50];
scanf("%s", e);
r = second = e;
while (second.find("kh") != -1) {
x = second.find("kh");
second.erase(second.begin() + x);
}
r = second;
while (second.find("oo") != -1) {
x = second.find("oo");
second[x] = 'u';
second.erase(second.begin() + x + 1);
}
while (r.find("u") != -1) {
x = r.find("u");
r[x] = 'o';
r.insert(r.begin() + x, 'o');
}
vis1[second] = 1;
vis2[r] = 1;
}
printf("%d\n", min(vis1.size(), vis2.size()));
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Problem statement
A programming contest will be held in the Russian Federation. The contest has N questions and has M participants. Question i has a score a_i, and it is known that participant j's ability is b_j. For problem i and participant j, participant j can always solve problem i if a_i ≤ b_j and only then. The score of a participant through the contest is the sum of the scores of the problems that the person was able to solve. Participant j also sets a target score c_j for this contest.
Determine if each participant can score more than the target score.
input
The input is given in the following format.
N
a_ {0} a_ {1} a_ {2}… a_ {N−1}
M
b_ {0} b_ {1} b_ {2}… b_ {M−1}
c_ {0} c_ {1} c_ {2}… c_ {M−1}
Constraint
* All inputs are integers
* 1 \ ≤ N \ ≤ 300 \,000
* 1 \ ≤ M \ ≤ 300 \,000
* 0 \ ≤ a_ {i} \ ≤ 1 \, 000 \,000
* 0 \ ≤ b_ {i} \ ≤ 1 \, 000 \,000
* 0 \ ≤ c_ {i} \ ≤ ∑a_k
output
Print the answer on line M. On the i-line, output `Yes` if the participant i-1 can get more points than the target score, and` No` if not.
sample
Sample input 1
6
1 2 1 3 4 5
7
1 3 4 5 3 1 0
2 4 5 3 4 5 3
Sample output 1
Yes
Yes
Yes
Yes
Yes
No
No
The points obtained by each participant are as follows.
* Participant 0: 1 + 1 = 2
* Participant 1: 1 + 2 + 1 + 3 = 7
* Participant 2: 1 + 2 + 1 + 3 + 4 = 11
* Participant 3: 1 + 2 + 1 + 3 + 4 + 5 = 16
* Participant 4: 1 + 2 + 1 + 3 = 7
* Participant 5: 1 + 1 = 2
* Participants 6: 0
Sample input 2
8
1 1 2 3 3 4 6 100
Four
1 3 4 99
1 10 15 120
Sample output 2
Yes
Yes
No
No
Example
Input
6
1 2 1 3 4 5
7
1 3 4 5 3 1 0
2 4 5 3 4 5 3
Output
Yes
Yes
Yes
Yes
Yes
No
No
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
//#define ll ll
signed main(){
ll n; cin >> n;
vector<ll>v(n);
for(auto && itr : v){
cin >> itr;
}
ll m; cin >> m;
vector<ll>u(m);
for(auto && itr : u){
cin >> itr;
}
vector<ll>c(m);
for(auto && itr : c){
cin >> itr;
}
sort(v.begin(),v.end());
vector<ll>sum = v;
for(ll i = 1; i < n;i++){
sum[i]+=sum[i-1];
}
for(ll i = 0; i < u.size(); i++){
ll idx = (ll)(lower_bound(v.begin(), v.end(),u[i]+1) - v.begin());
if((sum[idx-1] >= c[i] and idx )or c[i] == 0) cout << "Yes" << endl;
else cout << "No" << endl;
}
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
Takahashi has decided to hold fastest-finger-fast quiz games. Kizahashi, who is in charge of making the scoreboard, is struggling to write the program that manages the players' scores in a game, which proceeds as follows.
A game is played by N players, numbered 1 to N. At the beginning of a game, each player has K points.
When a player correctly answers a question, each of the other N-1 players receives minus one (-1) point. There is no other factor that affects the players' scores.
At the end of a game, the players with 0 points or lower are eliminated, and the remaining players survive.
In the last game, the players gave a total of Q correct answers, the i-th of which was given by Player A_i. For Kizahashi, write a program that determines whether each of the N players survived this game.
Constraints
* All values in input are integers.
* 2 \leq N \leq 10^5
* 1 \leq K \leq 10^9
* 1 \leq Q \leq 10^5
* 1 \leq A_i \leq N\ (1 \leq i \leq Q)
Input
Input is given from Standard Input in the following format:
N K Q
A_1
A_2
.
.
.
A_Q
Output
Print N lines. The i-th line should contain `Yes` if Player i survived the game, and `No` otherwise.
Examples
Input
6 3 4
3
1
3
2
Output
No
No
Yes
No
No
No
Input
6 5 4
3
1
3
2
Output
Yes
Yes
Yes
Yes
Yes
Yes
Input
10 13 15
3
1
4
1
5
9
2
6
5
3
5
8
9
7
9
Output
No
No
No
No
Yes
No
No
No
Yes
No
### Response
```cpp
#include <cstdio>
int a[100005];
int main()
{
int n,k,q;
scanf("%d%d%d",&n,&k,&q);
for(int i=1;i<=q;i++)
{
int x;
scanf("%d",&x);
a[x]++;
}
for(int i=1;i<=n;i++)
puts(k-q+a[i]>0?"Yes":"No");
return 0;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
Let us define the FizzBuzz sequence a_1,a_2,... as follows:
* If both 3 and 5 divides i, a_i=\mbox{FizzBuzz}.
* If the above does not hold but 3 divides i, a_i=\mbox{Fizz}.
* If none of the above holds but 5 divides i, a_i=\mbox{Buzz}.
* If none of the above holds, a_i=i.
Find the sum of all numbers among the first N terms of the FizzBuzz sequence.
Constraints
* 1 \leq N \leq 10^6
Input
Input is given from Standard Input in the following format:
N
Output
Print the sum of all numbers among the first N terms of the FizzBuzz sequence.
Examples
Input
15
Output
60
Input
1000000
Output
266666333332
### Response
```cpp
#include<iostream>
using namespace std;
int n;
long long ans;
int main(){
cin>>n;
for(int i=1;i<=n;i++)
if(i%3!=0&&i%5!=0)ans+=i;
cout<<ans;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
Dima loves representing an odd number as the sum of multiple primes, and Lisa loves it when there are at most three primes. Help them to represent the given number as the sum of at most than three primes.
More formally, you are given an odd numer n. Find a set of numbers pi (1 ≤ i ≤ k), such that
1. 1 ≤ k ≤ 3
2. pi is a prime
3. <image>
The numbers pi do not necessarily have to be distinct. It is guaranteed that at least one possible solution exists.
Input
The single line contains an odd number n (3 ≤ n < 109).
Output
In the first line print k (1 ≤ k ≤ 3), showing how many numbers are in the representation you found.
In the second line print numbers pi in any order. If there are multiple possible solutions, you can print any of them.
Examples
Input
27
Output
3
5 11 11
Note
A prime is an integer strictly larger than one that is divisible only by one and by itself.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
bool p(int n) {
if (n <= 1) return false;
for (long long i = 2; i <= sqrt(n); i++)
if (n % i == 0) return false;
return true;
}
int main() {
long long s, n, j, o = 0, a[3] = {};
cin >> n;
j = n;
for (long long i = 0; i < 300; i++) {
if (p(j)) break;
j--;
}
a[0] = j;
j = n - j;
for (long long i = 2; i <= j; i++) {
if (p(i)) {
a[1] = i;
if (p(j - i)) {
a[2] = j - i;
break;
}
}
}
for (long long i = 0; i < 3; i++)
if (a[i]) o++;
cout << o;
cout << endl;
for (long long i = 0; i < o; i++) {
cout << a[i];
cout << " ";
}
return 0;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
problem
You are looking for a constellation in a picture of the starry sky. The photo always contains exactly one figure with the same shape, orientation, and size as the constellation you are looking for. However, there is a possibility that extra stars are shown in the photograph other than the stars that make up the constellation.
For example, the constellations in Figure 1 are included in the photo in Figure 2 (circled). If you translate the coordinates of a star in a given constellation by 2 in the x direction and −3 in the y direction, it will be the position in the photo.
Given the shape of the constellation you want to look for and the position of the star in the picture, write a program that answers the amount to translate to convert the coordinates of the constellation to the coordinates in the picture.
<image> | <image>
--- | ---
Figure 1: The constellation you want to find | Figure 2: Photograph of the starry sky
input
The input consists of multiple datasets. Each dataset is given in the following format.
The first line of the input contains the number of stars m that make up the constellation you want to find. In the following m line, the integers indicating the x and y coordinates of the m stars that make up the constellation you want to search for are written separated by blanks. The number n of stars in the photo is written on the m + 2 line. In the following n lines, the integers indicating the x and y coordinates of the n stars in the photo are written separated by blanks.
The positions of the m stars that make up the constellation are all different. Also, the positions of the n stars in the picture are all different. 1 ≤ m ≤ 200, 1 ≤ n ≤ 1000. The x and y coordinates of a star are all 0 or more and 1000000 or less.
When m is 0, it indicates the end of input. The number of datasets does not exceed 5.
output
The output of each dataset consists of one line, with two integers separated by blanks. These show how much the coordinates of the constellation you want to find should be translated to become the coordinates in the photo. The first integer is the amount to translate in the x direction, and the second integer is the amount to translate in the y direction.
Examples
Input
5
8 5
6 4
4 3
7 10
0 10
10
10 5
2 7
9 7
8 10
10 2
1 2
8 1
6 7
6 0
0 9
5
904207 809784
845370 244806
499091 59863
638406 182509
435076 362268
10
757559 866424
114810 239537
519926 989458
461089 424480
674361 448440
81851 150384
459107 795405
299682 6700
254125 362183
50795 541942
0
Output
2 -3
-384281 179674
Input
None
Output
None
### Response
```cpp
#include<cstdio>
#include<set>
#include<map>
using namespace std;
int main(){
while(1){
int m, n ;
int seiza[200][2], stars[1000][2];
set< pair<int, int> > starset;
scanf("%d", &m);
if(m == 0){
return 0;
}
for(int i = 0;i < m;i++){
int xi, yi;
scanf("%d%d", &xi, &yi);
seiza[i][0] = xi;
seiza[i][1] = yi;
}
scanf("%d", &n);
for(int i = 0;i < n;i++){
int xi, yi;
scanf("%d%d", &xi, &yi);
stars[i][0] = xi;
stars[i][1] = yi;
starset.insert(make_pair(xi, yi));
}
for(int i = 0;i < n;i++){
int xdis = stars[i][0] - seiza[0][0];
int ydis = stars[i][1] - seiza[0][1];
int j;
for(j = 1;j < m;j++){
if(starset.find(make_pair(seiza[j][0] + xdis, seiza[j][1] + ydis)) == starset.end()){
break;
}
}
if(j == m){
printf("%d %d\n", xdis, ydis);
break;
}
}
}
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
You are given a rooted tree consisting of n vertices numbered from 1 to n. The root of the tree is a vertex number 1.
A tree is a connected undirected graph with n-1 edges.
You are given m queries. The i-th query consists of the set of k_i distinct vertices v_i[1], v_i[2], ..., v_i[k_i]. Your task is to say if there is a path from the root to some vertex u such that each of the given k vertices is either belongs to this path or has the distance 1 to some vertex of this path.
Input
The first line of the input contains two integers n and m (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5) — the number of vertices in the tree and the number of queries.
Each of the next n-1 lines describes an edge of the tree. Edge i is denoted by two integers u_i and v_i, the labels of vertices it connects (1 ≤ u_i, v_i ≤ n, u_i ≠ v_i).
It is guaranteed that the given edges form a tree.
The next m lines describe queries. The i-th line describes the i-th query and starts with the integer k_i (1 ≤ k_i ≤ n) — the number of vertices in the current query. Then k_i integers follow: v_i[1], v_i[2], ..., v_i[k_i] (1 ≤ v_i[j] ≤ n), where v_i[j] is the j-th vertex of the i-th query.
It is guaranteed that all vertices in a single query are distinct.
It is guaranteed that the sum of k_i does not exceed 2 ⋅ 10^5 (∑_{i=1}^{m} k_i ≤ 2 ⋅ 10^5).
Output
For each query, print the answer — "YES", if there is a path from the root to some vertex u such that each of the given k vertices is either belongs to this path or has the distance 1 to some vertex of this path and "NO" otherwise.
Example
Input
10 6
1 2
1 3
1 4
2 5
2 6
3 7
7 8
7 9
9 10
4 3 8 9 10
3 2 4 6
3 2 1 5
3 4 8 2
2 6 10
3 5 4 7
Output
YES
YES
YES
YES
NO
NO
Note
The picture corresponding to the example:
<image>
Consider the queries.
The first query is [3, 8, 9, 10]. The answer is "YES" as you can choose the path from the root 1 to the vertex u=10. Then vertices [3, 9, 10] belong to the path from 1 to 10 and the vertex 8 has distance 1 to the vertex 7 which also belongs to this path.
The second query is [2, 4, 6]. The answer is "YES" as you can choose the path to the vertex u=2. Then the vertex 4 has distance 1 to the vertex 1 which belongs to this path and the vertex 6 has distance 1 to the vertex 2 which belongs to this path.
The third query is [2, 1, 5]. The answer is "YES" as you can choose the path to the vertex u=5 and all vertices of the query belong to this path.
The fourth query is [4, 8, 2]. The answer is "YES" as you can choose the path to the vertex u=9 so vertices 2 and 4 both have distance 1 to the vertex 1 which belongs to this path and the vertex 8 has distance 1 to the vertex 7 which belongs to this path.
The fifth and the sixth queries both have answer "NO" because you cannot choose suitable vertex u.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void print(vector<long long> a) {
for (long long i = 1; i < a.size(); i++) {
cout << a[i] << " ";
}
cout << endl;
}
void printPair(vector<pair<long long, long long>> a) {
for (long long i = 1; i < a.size(); i++) {
cout << a[i].first << "--" << a[i].second << endl;
}
}
void dfsUtil(long long *time, vector<long long> graph[], vector<bool> &check,
long long vertex, long long depth, vector<long long> &depthList,
vector<long long> &parentList,
vector<pair<long long, long long>> &timeList) {
long long i;
check[vertex] = true;
depthList[vertex] = depth;
timeList[vertex].first = *time;
for (i = 0; i < graph[vertex].size(); i++) {
if (check[graph[vertex][i]] == false) {
*time = *time + 1;
parentList[graph[vertex][i]] = vertex;
dfsUtil(time, graph, check, graph[vertex][i], depthList[vertex] + 1,
depthList, parentList, timeList);
}
}
*time = *time + 1;
timeList[vertex].second = *time;
}
void DFS(vector<long long> graph[], long long totalVertices,
vector<long long> &depthList, vector<long long> &parentList,
vector<pair<long long, long long>> &timeList) {
long long depth = 1;
long long time = 0;
vector<bool> check(totalVertices, false);
dfsUtil(&time, graph, check, 1, depth, depthList, parentList, timeList);
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n, q;
cin >> n >> q;
vector<long long> graph[n + 1];
for (long long i = 1; i < n; i++) {
long long x, y;
cin >> x >> y;
graph[x].push_back(y);
graph[y].push_back(x);
}
vector<long long> parentList(n + 1, 0);
vector<long long> depthList(n + 1, 0);
vector<pair<long long, long long>> timeList(n + 1, make_pair(-1, -1));
parentList[1] = 1;
DFS(graph, n + 1, depthList, parentList, timeList);
while (q--) {
long long x;
cin >> x;
vector<long long> storeVertex;
long long maxDepthVertex = -1;
long long depthMax = INT_MIN;
while (x--) {
long long a;
cin >> a;
storeVertex.push_back(a);
if (depthList[a] > depthMax) {
maxDepthVertex = a;
depthMax = depthList[a];
}
}
long long time1 = 0;
long long time2 = timeList[maxDepthVertex].second;
long long check = 1;
for (long long i = 0; i < storeVertex.size(); i++) {
if ((timeList[storeVertex[i]].first <= time2 &&
timeList[storeVertex[i]].second >= time2) ||
(timeList[parentList[storeVertex[i]]].first <= time2 &&
timeList[parentList[storeVertex[i]]].second >= time2)) {
check = 1;
} else {
check = 0;
break;
}
}
if (check == 1)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
One day in the IT lesson Anna and Maria learned about the lexicographic order.
String x is lexicographically less than string y, if either x is a prefix of y (and x ≠ y), or there exists such i (1 ≤ i ≤ min(|x|, |y|)), that xi < yi, and for any j (1 ≤ j < i) xj = yj. Here |a| denotes the length of the string a. The lexicographic comparison of strings is implemented by operator < in modern programming languages.
The teacher gave Anna and Maria homework. She gave them a string of length n. They should write out all substrings of the given string, including the whole initial string, and the equal substrings (for example, one should write out the following substrings from the string "aab": "a", "a", "aa", "ab", "aab", "b"). The resulting strings should be sorted in the lexicographical order. The cunning teacher doesn't want to check all these strings. That's why she said to find only the k-th string from the list. Help Anna and Maria do the homework.
Input
The first line contains a non-empty string that only consists of small Latin letters ("a"-"z"), whose length does not exceed 105. The second line contains the only integer k (1 ≤ k ≤ 105).
Output
Print the string Anna and Maria need — the k-th (in the lexicographical order) substring of the given string. If the total number of substrings is less than k, print a string saying "No such line." (without the quotes).
Examples
Input
aa
2
Output
a
Input
abc
5
Output
bc
Input
abab
7
Output
b
Note
In the second sample before string "bc" follow strings "a", "ab", "abc", "b".
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
multiset<pair<string, int> > mul;
int main() {
string ss;
int k;
cin >> ss >> k;
for (int i = 0; i < ss.size(); i++) {
string temp;
temp += ss[i];
mul.insert({temp, i});
}
long long n = ss.size();
if (2 * k > n * (n + 1)) {
cout << "No such line." << endl;
} else {
pair<string, int> p, ans;
while (k--) {
ans = p = *mul.begin();
mul.erase(mul.begin());
if (p.second + 1 < n) {
p.first += ss[p.second + 1];
p.second += 1;
mul.insert(p);
}
}
cout << ans.first << endl;
}
return 0;
}
``` |
### Prompt
Your challenge is to write 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;
inline long long solve_win(long long from, long long to) {
if (from > to) {
return 1;
}
for (;;) {
long long nto = to / 2;
if ((to & 1) || from > nto) {
return (to - from) & 1;
}
long long nto2 = nto / 2 + 1;
if (from >= nto2) {
return 1;
}
to = nto2 - 1;
}
}
inline long long solve_lose(long long from, long long to) {
if (from > to) {
return 0;
}
if (from * 2 > to) {
return 1;
}
return solve_win(from, to / 2);
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long T;
cin >> T;
vector<vector<long long>> can_second(T, vector<long long>(2)),
can_first(T, vector<long long>(2));
long long ptr = 0;
for (long long iter = 0; iter < T; iter++) {
long long from, to;
cin >> from >> to;
can_first[iter][0] = solve_win(from, to);
can_first[iter][1] = solve_lose(from, to);
if (solve_win(from * 2ll, to) && solve_win(from + 1, to)) {
can_second[iter][0] = 1;
}
if (solve_lose(from * 2ll, to) && solve_lose(from + 1, to)) {
can_second[iter][1] = 1;
}
}
vector<bool> can(2, false);
can[0] = true;
for (long long iter = 0; iter < T; iter++) {
vector<bool> ncan(2, false);
if (can[0]) {
if (can_first[iter][0]) {
ncan[1] = true;
}
if (can_first[iter][1]) {
ncan[0] = true;
}
}
if (can[1]) {
if (can_second[iter][0]) {
ncan[1] = true;
}
if (can_second[iter][1]) {
ncan[0] = true;
}
}
can = ncan;
}
cout << can[1] << ' ' << can[0] << '\n';
}
``` |
### Prompt
Create a solution in cpp for the following problem:
The only difference between easy and hard versions is constraints.
There are n kids, each of them is reading a unique book. At the end of any day, the i-th kid will give his book to the p_i-th kid (in case of i = p_i the kid will give his book to himself). It is guaranteed that all values of p_i are distinct integers from 1 to n (i.e. p is a permutation). The sequence p doesn't change from day to day, it is fixed.
For example, if n=6 and p=[4, 6, 1, 3, 5, 2] then at the end of the first day the book of the 1-st kid will belong to the 4-th kid, the 2-nd kid will belong to the 6-th kid and so on. At the end of the second day the book of the 1-st kid will belong to the 3-th kid, the 2-nd kid will belong to the 2-th kid and so on.
Your task is to determine the number of the day the book of the i-th child is returned back to him for the first time for every i from 1 to n.
Consider the following example: p = [5, 1, 2, 4, 3]. The book of the 1-st kid will be passed to the following kids:
* after the 1-st day it will belong to the 5-th kid,
* after the 2-nd day it will belong to the 3-rd kid,
* after the 3-rd day it will belong to the 2-nd kid,
* after the 4-th day it will belong to the 1-st kid.
So after the fourth day, the book of the first kid will return to its owner. The book of the fourth kid will return to him for the first time after exactly one day.
You have to answer q independent queries.
Input
The first line of the input contains one integer q (1 ≤ q ≤ 200) — the number of queries. Then q queries follow.
The first line of the query contains one integer n (1 ≤ n ≤ 200) — the number of kids in the query. The second line of the query contains n integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n, all p_i are distinct, i.e. p is a permutation), where p_i is the kid which will get the book of the i-th kid.
Output
For each query, print the answer on it: n integers a_1, a_2, ..., a_n, where a_i is the number of the day the book of the i-th child is returned back to him for the first time in this query.
Example
Input
6
5
1 2 3 4 5
3
2 3 1
6
4 6 2 1 5 3
1
1
4
3 4 1 2
5
5 1 2 4 3
Output
1 1 1 1 1
3 3 3
2 3 3 2 1 3
1
2 2 2 2
4 4 4 1 4
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int maxn = 2e5 + 5;
const int mod = 1e9 + 7;
int p[maxn];
int a[maxn];
int n;
bool vis[maxn];
int main() {
int T;
scanf("%d", &T);
while (T--) {
scanf("%d", &n);
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= n; i++) scanf("%d", &p[i]);
for (int i = 1; i <= n; i++) {
if (vis[i]) continue;
vis[i] = true;
int t = p[i];
int cnt = 1;
while (t != i) {
vis[t] = true;
t = p[t];
cnt++;
}
t = p[i];
a[i] = cnt;
while (t != i) {
a[t] = cnt;
t = p[t];
}
}
for (int i = 1; i <= n; i++) {
printf("%d ", a[i]);
}
printf("\n");
}
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
New AtCoder City has an infinite grid of streets, as follows:
* At the center of the city stands a clock tower. Let (0, 0) be the coordinates of this point.
* A straight street, which we will call East-West Main Street, runs east-west and passes the clock tower. It corresponds to the x-axis in the two-dimensional coordinate plane.
* There are also other infinitely many streets parallel to East-West Main Street, with a distance of 1 between them. They correspond to the lines \ldots, y = -2, y = -1, y = 1, y = 2, \ldots in the two-dimensional coordinate plane.
* A straight street, which we will call North-South Main Street, runs north-south and passes the clock tower. It corresponds to the y-axis in the two-dimensional coordinate plane.
* There are also other infinitely many streets parallel to North-South Main Street, with a distance of 1 between them. They correspond to the lines \ldots, x = -2, x = -1, x = 1, x = 2, \ldots in the two-dimensional coordinate plane.
There are N residential areas in New AtCoder City. The i-th area is located at the intersection with the coordinates (X_i, Y_i) and has a population of P_i. Each citizen in the city lives in one of these areas.
The city currently has only two railroads, stretching infinitely, one along East-West Main Street and the other along North-South Main Street.
M-kun, the mayor, thinks that they are not enough for the commuters, so he decides to choose K streets and build a railroad stretching infinitely along each of those streets.
Let the walking distance of each citizen be the distance from his/her residential area to the nearest railroad.
M-kun wants to build railroads so that the sum of the walking distances of all citizens, S, is minimized.
For each K = 0, 1, 2, \dots, N, what is the minimum possible value of S after building railroads?
Constraints
* 1 \leq N \leq 15
* -10 \ 000 \leq X_i \leq 10 \ 000
* -10 \ 000 \leq Y_i \leq 10 \ 000
* 1 \leq P_i \leq 1 \ 000 \ 000
* The locations of the N residential areas, (X_i, Y_i), are all distinct.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
X_1 Y_1 P_1
X_2 Y_2 P_2
: : :
X_N Y_N P_N
Output
Print the answer in N+1 lines.
The i-th line (i = 1, \ldots, N+1) should contain the minimum possible value of S after building railroads for the case K = i-1.
Examples
Input
3
1 2 300
3 3 600
1 4 800
Output
2900
900
0
0
Input
5
3 5 400
5 3 700
5 5 1000
5 7 700
7 5 400
Output
13800
1600
0
0
0
0
Input
6
2 5 1000
5 2 1100
5 5 1700
-2 -5 900
-5 -2 600
-5 -5 2200
Output
26700
13900
3200
1200
0
0
0
Input
8
2 2 286017
3 1 262355
2 -2 213815
1 -3 224435
-2 -2 136860
-3 -1 239338
-2 2 217647
-1 3 141903
Output
2576709
1569381
868031
605676
366338
141903
0
0
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
#define SZ(a) ((int)(a).size())
#define PB push_back
#define MP make_pair
const int maxn = 200009;
const int MOD = 1e9 + 7;
int64_t X[1<<15][15],Y[1<<15][15];
int64_t AX[15],AY[15],AP[15],ans[16];
int main(){
#ifdef LOCAL
freopen(".a.in", "r", stdin);
#endif
ios_base::sync_with_stdio(false),cout.tie(0),cin.tie(0);
int n;cin>>n;
for(int i=0;i<n;++i)cin>>AX[i]>>AY[i]>>AP[i];
for(int i=0;i<(1<<n);++i){
for(int j=0;j<n;++j){
X[i][j]=abs(AX[j]);
for(int k=0;k<n;++k)if(i>>k&1)X[i][j]=min(X[i][j],abs(AX[k]-AX[j]));
Y[i][j]=abs(AY[j]);
for(int k=0;k<n;++k)if(i>>k&1)Y[i][j]=min(Y[i][j],abs(AY[k]-AY[j]));
}
}
for(int i=0;i<=n;++i)ans[i]=1e18;
for(int i=0;i<(1<<n);++i){
int c=__builtin_popcount(i);
for(int j=i;;j=(j-1)&i){
int64_t tmp=0;
for(int a=0;a<n;++a){
tmp+=min(X[j][a],Y[j^i][a])*AP[a];
}
ans[c]=min(ans[c],tmp);
if(j==0)break;
}
}
for(int i=0;i<=n;++i)cout<<ans[i]<<'\n';
return 0;
}
//2020.07.25 21:54:09
``` |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.