text
stringlengths 424
69.5k
|
|---|
### Prompt
Please provide a Cpp coded solution to the problem described below:
You're given an array a. You should repeat the following operation k times: find the minimum non-zero element in the array, print it, and then subtract it from all the non-zero elements of the array. If all the elements are 0s, just print 0.
Input
The first line contains integers n and k (1 β€ n,k β€ 10^5), the length of the array and the number of operations you should perform.
The second line contains n space-separated integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9), the elements of the array.
Output
Print the minimum non-zero element before each operation in a new line.
Examples
Input
3 5
1 2 3
Output
1
1
1
0
0
Input
4 2
10 3 5 3
Output
3
2
Note
In the first sample:
In the first step: the array is [1,2,3], so the minimum non-zero element is 1.
In the second step: the array is [0,1,2], so the minimum non-zero element is 1.
In the third step: the array is [0,0,1], so the minimum non-zero element is 1.
In the fourth and fifth step: the array is [0,0,0], so we printed 0.
In the second sample:
In the first step: the array is [10,3,5,3], so the minimum non-zero element is 3.
In the second step: the array is [7,0,2,0], so the minimum non-zero element is 2.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m;
set<int> st;
int main() {
cin >> n >> m;
st.insert(0);
while (n--) {
int a;
cin >> a;
st.insert(a);
}
auto it = st.begin();
for (int i = 0; i < m; i++) {
if (next(it) == st.end()) {
cout << 0 << endl;
} else {
cout << *next(it) - *it << endl;
it = next(it);
}
}
return 0;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
A flowerbed has many flowers and two fountains.
You can adjust the water pressure and set any values r1(r1 β₯ 0) and r2(r2 β₯ 0), giving the distances at which the water is spread from the first and second fountain respectively. You have to set such r1 and r2 that all the flowers are watered, that is, for each flower, the distance between the flower and the first fountain doesn't exceed r1, or the distance to the second fountain doesn't exceed r2. It's OK if some flowers are watered by both fountains.
You need to decrease the amount of water you need, that is set such r1 and r2 that all the flowers are watered and the r12 + r22 is minimum possible. Find this minimum value.
Input
The first line of the input contains integers n, x1, y1, x2, y2 (1 β€ n β€ 2000, - 107 β€ x1, y1, x2, y2 β€ 107) β the number of flowers, the coordinates of the first and the second fountain.
Next follow n lines. The i-th of these lines contains integers xi and yi ( - 107 β€ xi, yi β€ 107) β the coordinates of the i-th flower.
It is guaranteed that all n + 2 points in the input are distinct.
Output
Print the minimum possible value r12 + r22. Note, that in this problem optimal answer is always integer.
Examples
Input
2 -1 0 5 3
0 2
5 2
Output
6
Input
4 0 0 5 0
9 4
8 3
-1 0
1 4
Output
33
Note
The first sample is (r12 = 5, r22 = 1): <image> The second sample is (r12 = 1, r22 = 32): <image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long int x[3000], y[3000], a[3000], b[3000];
int main() {
long long int n, x1, x2, y1, y2, i, j;
cin >> n >> x1 >> y1 >> x2 >> y2;
for (i = 0; i < n; i++) {
cin >> x[i] >> y[i];
a[i] = (x[i] - x1) * (x[i] - x1) + (y[i] - y1) * (y[i] - y1);
b[i] = (x[i] - x2) * (x[i] - x2) + (y[i] - y2) * (y[i] - y2);
}
long long int p, q, ans = 10000000000000000;
for (i = 0; i < n; i++) {
p = a[i];
q = 0;
for (j = 0; j < n; j++) {
if (a[j] > p && b[j] > q) {
q = b[j];
}
}
ans = min(ans, (p + q));
p = b[i];
q = 0;
for (j = 0; j < n; j++) {
if (b[j] > p && a[j] > q) {
q = a[j];
}
}
ans = min(ans, (p + q));
}
cout << (ans) << endl;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
There are several days left before the fiftieth birthday of a famous Berland's writer Berlbury. In this connection the local library decided to make an exposition of the works of this famous science-fiction writer. It was decided as well that it is necessary to include into the exposition only those books that were published during a particular time period. It is obvious that if the books differ much in size, the visitors will not like it. That was why the organizers came to the opinion, that the difference between the highest and the lowest books in the exposition should be not more than k millimeters.
The library has n volumes of books by Berlbury, arranged in chronological order of their appearance. The height of each book in millimeters is know, it is hi. As Berlbury is highly respected in the city, the organizers want to include into the exposition as many books as possible, and to find out what periods of his creative work they will manage to cover. You are asked to help the organizers cope with this hard task.
Input
The first line of the input data contains two integer numbers separated by a space n (1 β€ n β€ 105) and k (0 β€ k β€ 106) β the amount of books by Berlbury in the library, and the maximum allowed height difference between the lowest and the highest books. The second line contains n integer numbers separated by a space. Each number hi (1 β€ hi β€ 106) is the height of the i-th book in millimeters.
Output
In the first line of the output data print two numbers a and b (separate them by a space), where a is the maximum amount of books the organizers can include into the exposition, and b β the amount of the time periods, during which Berlbury published a books, and the height difference between the lowest and the highest among these books is not more than k milllimeters.
In each of the following b lines print two integer numbers separated by a space β indexes of the first and the last volumes from each of the required time periods of Berlbury's creative work.
Examples
Input
3 3
14 12 10
Output
2 2
1 2
2 3
Input
2 0
10 10
Output
2 1
1 2
Input
4 5
8 19 10 13
Output
2 1
3 4
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void Weapons19() {
cin.sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
long long int fun(long long int m, vector<long long int> &v) {
map<long long int, long long int> z;
set<long long int> s;
for (long long int i = 0; i < m; i++) {
s.insert(v[i]);
z[v[i]]++;
}
long long int ans = *(--s.end()) - *s.begin();
for (long long int i = m; i < v.size(); i++) {
z[v[i - m]]--;
if (z[v[i - m]] == 0) s.erase(v[i - m]);
s.insert(v[i]);
z[v[i]]++;
ans = min(ans, *(--s.end()) - *s.begin());
}
return ans;
}
vector<pair<long long int, long long int> > p;
void fun2(vector<long long int> &v, long long int m, long long int k) {
map<long long int, long long int> z;
set<long long int> s;
long long int a = 0, b = 0;
while (1) {
if (b - a != m) {
z[v[b]]++;
s.insert(v[b]);
b++;
} else {
if (*(--s.end()) - *s.begin() <= k) p.push_back({a, b});
z[v[a]]--;
if (z[v[a]] == 0) s.erase(v[a]);
if (b == v.size()) break;
z[v[b]]++;
s.insert(v[b]);
a++;
b++;
}
}
}
int32_t main() {
Weapons19();
long long int n, k;
cin >> n >> k;
vector<long long int> v(n);
for (long long int i = 0; i < n; i++) cin >> v[i];
long long int s = 1, e = n;
while (s != e) {
long long int m = (s + e + 1) / 2;
if (fun(m, v) <= k)
s = m;
else
e = m - 1;
}
fun2(v, s, k);
cout << s << " " << p.size() << "\n";
for (auto a : p) cout << a.first + 1 << " " << a.second << "\n";
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
Your math teacher gave you the following problem:
There are n segments on the x-axis, [l_1; r_1], [l_2; r_2], β¦, [l_n; r_n]. The segment [l; r] includes the bounds, i.e. it is a set of such x that l β€ x β€ r. The length of the segment [l; r] is equal to r - l.
Two segments [a; b] and [c; d] have a common point (intersect) if there exists x that a β€ x β€ b and c β€ x β€ d. For example, [2; 5] and [3; 10] have a common point, but [5; 6] and [1; 4] don't have.
You should add one segment, which has at least one common point with each of the given segments and as short as possible (i.e. has minimal length). The required segment can degenerate to be a point (i.e a segment with length zero). The added segment may or may not be among the given n segments.
In other words, you need to find a segment [a; b], such that [a; b] and every [l_i; r_i] have a common point for each i, and b-a is minimal.
Input
The first line contains integer number t (1 β€ t β€ 100) β the number of test cases in the input. Then t test cases follow.
The first line of each test case contains one integer n (1 β€ n β€ 10^{5}) β the number of segments. The following n lines contain segment descriptions: the i-th of them contains two integers l_i,r_i (1 β€ l_i β€ r_i β€ 10^{9}).
The sum of all values n over all the test cases in the input doesn't exceed 10^5.
Output
For each test case, output one integer β the smallest possible length of the segment which has at least one common point with all given segments.
Example
Input
4
3
4 5
5 9
7 7
5
11 19
4 17
16 16
3 12
14 17
1
1 10
1
1 1
Output
2
4
0
0
Note
In the first test case of the example, we can choose the segment [5;7] as the answer. It is the shortest segment that has at least one common point with all given segments.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 2;
const int M = 1e5 + 2;
const int mod = 1e9 + 7;
const int inf = 1e9;
const long long INF = 1e18;
void data() { ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0); }
int t, n;
pair<int, int> p[N];
int main() {
data();
scanf("%d", &t);
while (t--) {
scanf("%d", &n);
int ml = 0, mr = inf;
for (int i = 0, l, r; i < n; ++i) {
scanf("%d %d", &l, &r);
ml = max(ml, l);
mr = min(mr, r);
}
if (ml < mr)
printf("0\n");
else
printf("%d\n", ml - mr);
}
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
Snuke found a record of a tree with N vertices in ancient ruins. The findings are as follows:
* The vertices of the tree were numbered 1,2,...,N, and the edges were numbered 1,2,...,N-1.
* Edge i connected Vertex a_i and b_i.
* The length of each edge was an integer between 1 and 10^{18} (inclusive).
* The sum of the shortest distances from Vertex i to Vertex 1,...,N was s_i.
From the information above, restore the length of each edge. The input guarantees that it is possible to determine the lengths of the edges consistently with the record. Furthermore, it can be proved that the length of each edge is uniquely determined in such a case.
Constraints
* 2 \leq N \leq 10^{5}
* 1 \leq a_i,b_i \leq N
* 1 \leq s_i \leq 10^{18}
* The given graph is a tree.
* All input values are integers.
* It is possible to consistently restore the lengths of the edges.
* In the restored graph, the length of each edge is an integer between 1 and 10^{18} (inclusive).
Input
Input is given from Standard Input in the following format:
N
a_1 b_1
:
a_{N-1} b_{N-1}
s_1 s_2 ... s_{N}
Output
Print N-1 lines. The i-th line must contain the length of Edge i.
Examples
Input
4
1 2
2 3
3 4
8 6 6 8
Output
1
2
1
Input
5
1 2
1 3
1 4
1 5
10 13 16 19 22
Output
1
2
3
4
Input
15
9 10
9 15
15 4
4 13
13 2
13 11
2 14
13 6
11 1
1 12
12 3
12 7
2 5
14 8
1154 890 2240 883 2047 2076 1590 1104 1726 1791 1091 1226 841 1000 901
Output
5
75
2
6
7
50
10
95
9
8
78
28
89
8
### Response
```cpp
#include <bits/stdc++.h>
typedef long long ll;
#define FOR(i,a,b) for(ll i=(a);i<(b);i++)
#define REP(i,a) FOR(i,0,a)
using namespace std;
const ll MAX_N=1e5,INF=1e18;
ll N,S[MAX_N];
typedef pair<ll,ll> P;
vector<P> G[MAX_N];
ll ans[MAX_N-1],chl[MAX_N],unv,uninx,dis[MAX_N];
void calchl(ll v,ll p){
for(auto pa:G[v]){
ll e=pa.first;
if(e!=p){
calchl(e,v);
chl[v]+=chl[e];
}
}
chl[v]++;
}
void dfs(ll v,ll p){
REP(i,G[v].size()){
P e=G[v][i];
if(e.first!=p){
if(2*chl[e.first]-N==0){
unv=v;
uninx=i;
}else{
ans[e.second]=(S[v]-S[e.first])/(2*chl[e.first]-N);
}
dfs(e.first,v);
}
}
}
void caldis(ll v,ll p,ll d){
dis[v]=d;
for(auto e:G[v]){
if(e.first!=p){
caldis(e.first,v,min(d+ans[e.second],INF+1));
}
}
}
int main(){
scanf("%lld",&N);
REP(i,N-1){
ll a,b;
scanf("%lld %lld",&a,&b);
a--;
b--;
G[a].push_back(P(b,i));
G[b].push_back(P(a,i));
}
REP(i,N)scanf("%lld",S+i);
calchl(0,-1);
unv=-1;
dfs(0,-1);
if(unv!=-1){
ll lb=1,ub=INF+1;
while(ub-lb>1){
ll mid=(lb+ub)>>1;
ans[G[unv][uninx].second]=mid;
caldis(0,-1,0);
ll sm=0;
REP(i,N){
sm+=dis[i];
if(sm>INF){
sm=INF+1;
}
}
if(sm<=S[0]){
lb=mid;
}else{
ub=mid;
}
}
ans[G[unv][uninx].second]=lb;
}
REP(i,N-1){
printf("%lld\n",ans[i]);
}
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
After his birthday party, Timofey went to his favorite tree alley in a park. He wants to feed there his favorite birds β crows.
It's widely known that each tree is occupied by a single crow family. The trees in the alley form a row and are numbered from 1 to n. Some families are friends to each other. For some reasons, two families can be friends only if they live not too far from each other, more precisely, there is no more than k - 1 trees between any pair of friend families. Formally, the family on the u-th tree and the family on the v-th tree can be friends only if |u - v| β€ k holds.
One of the friendship features is that if some family learns that Timofey is feeding crows somewhere, it notifies about this all friend families. Thus, after Timofey starts to feed crows under some tree, all the families that are friends to the family living on this tree, as well as their friends and so on, fly to the feeding place. Of course, the family living on the tree also comes to the feeding place.
Today Timofey came to the alley and noticed that all the families that live on trees with numbers strictly less than l or strictly greater than r have flown away. Thus, it is not possible to pass the information about feeding through them. Moreover, there is no need to feed them. Help Timofey to learn what is the minimum number of trees under which he has to feed crows so that all the families that have remained will get the information about feeding. You are given several situations, described by integers l and r, you need to calculate the answer for all of them.
Input
The first line contains integers n and k (1 β€ n β€ 105, 1 β€ k β€ 5), where n is the number of trees, and k is the maximum possible distance between friend families.
The next line contains single integer m (0 β€ m β€ nΒ·k) β the number of pair of friend families.
Each of the next m lines contains two integers u and v (1 β€ u, v β€ 105), that means that the families on trees u and v are friends. It is guaranteed that u β v and |u - v| β€ k. All the given pairs are distinct.
The next line contains single integer q (1 β€ q β€ 105) β the number of situations you need to calculate the answer in.
Each of the next q lines contains two integers l and r (1 β€ l β€ r β€ 105), that means that in this situation families that have flown away lived on such trees x, so that either x < l or x > r.
Output
Print q lines. Line i should contain single integer β the answer in the i-th situation.
Example
Input
5 3
3
1 3
2 3
4 5
5
1 1
1 2
2 3
1 3
1 5
Output
1
2
1
1
2
Note
In the first example the following family pairs are friends: (1, 3), (2, 3) and (4, 5).
* In the first situation only the first family has remained, so the answer is 1.
* In the second situation the first two families have remained, and they aren't friends, so the answer is 2.
* In the third situation the families 2 and 3 are friends, so it is enough to feed any of them, the answer is 1.
* In the fourth situation we can feed the first family, then the third family will get the information from the first family, and the second family will get the information from the third. The answer is 1.
* In the fifth situation we can feed the first and the fifth families, so the answer is 2.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct DisjointSet {
vector<int> p, r;
int c;
DisjointSet(int n) : p(n, 0), r(n, 0), c(n) {
for (auto i = (0); i < (n); i++) p[i] = i;
}
int find(int a) {
int x = a;
while (p[x] != x) x = p[x];
while (p[a] != x) {
int pa = p[a];
p[a] = x;
a = pa;
}
return x;
}
void unio(int a, int b) {
a = find(a);
b = find(b);
if (a == b) return;
c--;
if (r[a] < r[b])
p[a] = b;
else if (r[a] > r[b])
p[b] = a;
else {
p[b] = a;
r[a]++;
}
}
};
int main() {
ios::sync_with_stdio(false);
int n, k, m;
cin >> n >> k >> m;
vector<set<int>> graph(n);
vector<vector<DisjointSet>> ds;
int d = 1, c = 0;
while (d <= n) {
ds.emplace_back();
for (auto i = (0); i < ((n + d - 1) / d); i++) ds.back().emplace_back(d);
d <<= 1;
c++;
}
for (auto i = (0); i < (m); i++) {
int a, b;
cin >> a >> b;
a--;
b--;
graph[a].insert(b);
graph[b].insert(a);
for (auto c = ((int)ds.size()) - 1; c >= (0); c--) {
if ((a >> c) != (b >> c)) break;
ds[c][a >> c].unio(a - ((a >> c) << c), b - ((b >> c) << c));
}
}
int q;
cin >> q;
for (auto i = (0); i < (q); i++) {
int l, r;
cin >> l >> r;
if (l-- == r) {
cout << 1 << endl;
continue;
}
int f = 0;
map<int, int> ind;
auto getind = [&](int a) {
auto it = ind.find(a);
if (it != ind.end()) return it->second;
ind[a] = f;
return f++;
};
DisjointSet ds2(512);
int ret = 0;
vector<tuple<int, int, int>> prev;
prev.emplace_back(0, 0, -1);
auto merge = [&]() {
ret += ds[c][l >> c].c;
for (auto pi = ((int)prev.size()) - 1; pi >= (0); pi--) {
int pl, pr, pc;
tie(pl, pr, pc) = prev[pi];
if (pr < l - k) break;
for (auto a = (max(pl, l - k)); a < (pr); a++)
for (auto b = (l); b < (l + min(d, k)); b++) {
if (graph[a].count(b))
ds2.unio(getind(ds[pc][a >> pc].find(a - ((a >> pc) << pc)) +
((a >> pc) << pc)),
getind(ds[c][b >> c].find(b - ((b >> c) << c)) +
((b >> c) << c)));
}
}
prev.emplace_back(l, l + d, c);
l += d;
};
c = 0, d = 1;
while (d <= r - l) {
if (l & d) merge();
d <<= 1;
c++;
}
while (d > 0) {
d >>= 1;
c--;
if ((r - l) & d) merge();
}
cout << (ret + ds2.c - 512) << endl;
}
return 0;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
After the Search Ultimate program that searched for strings in a text failed, Igor K. got to think: "Why on Earth does my program work so slowly?" As he double-checked his code, he said: "My code contains no errors, yet I know how we will improve Search Ultimate!" and took a large book from the shelves. The book read "Azembler. Principally New Approach".
Having carefully thumbed through the book, Igor K. realised that, as it turns out, you can multiply the numbers dozens of times faster. "Search Ultimate will be faster than it has ever been!" β the fellow shouted happily and set to work.
Let us now clarify what Igor's idea was. The thing is that the code that was generated by a compiler was far from perfect. Standard multiplying does work slower than with the trick the book mentioned.
The Azembler language operates with 26 registers (eax, ebx, ..., ezx) and two commands:
* [x] β returns the value located in the address x. For example, [eax] returns the value that was located in the address, equal to the value in the register eax.
* lea x, y β assigns to the register x, indicated as the first operand, the second operand's address. Thus, for example, the "lea ebx, [eax]" command will write in the ebx register the content of the eax register: first the [eax] operation will be fulfilled, the result of it will be some value that lies in the address written in eax. But we do not need the value β the next operation will be lea, that will take the [eax] address, i.e., the value in the eax register, and will write it in ebx.
On the first thought the second operation seems meaningless, but as it turns out, it is acceptable to write the operation as
lea ecx, [eax + ebx],
lea ecx, [k*eax]
or even
lea ecx, [ebx + k*eax],
where k = 1, 2, 4 or 8.
As a result, the register ecx will be equal to the numbers eax + ebx, k*eax and ebx + k*eax correspondingly. However, such operation is fulfilled many times, dozens of times faster that the usual multiplying of numbers. And using several such operations, one can very quickly multiply some number by some other one. Of course, instead of eax, ebx and ecx you are allowed to use any registers.
For example, let the eax register contain some number that we should multiply by 41. It takes us 2 lines:
lea ebx, [eax + 4*eax] // now ebx = 5*eax
lea eax, [eax + 8*ebx] // now eax = eax + 8*ebx = 41*eax
Igor K. got interested in the following question: what is the minimum number of lea operations needed to multiply by the given number n and how to do it? Your task is to help him.
Consider that at the initial moment of time eax contains a number that Igor K. was about to multiply by n, and the registers from ebx to ezx contain number 0. At the final moment of time the result can be located in any register.
Input
The input data contain the only integer n (1 β€ n β€ 255), which Igor K. is about to multiply.
Output
On the first line print number p, which represents the minimum number of lea operations, needed to do that. Then print the program consisting of p commands, performing the operations. It is guaranteed that such program exists for any n from 1 to 255.
Use precisely the following format of commands (here k is equal to 1, 2, 4 or 8, and x, y and z are any, even coinciding registers):
lea x, [y]
lea x, [y + z]
lea x, [k*y]
lea x, [y + k*z]
Please note that extra spaces at the end of a command are unacceptable.
Examples
Input
41
Output
2
lea ebx, [eax + 4*eax]
lea ecx, [eax + 8*ebx]
Input
2
Output
1
lea ebx, [eax + eax]
Input
4
Output
1
lea ebx, [4*eax]
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct reg {
int val;
int reg1;
int reg2;
int k;
};
reg r[11];
int en = 2;
int len = 2342;
reg bst[11];
bool calced[267] = {};
int x;
void DFS(int deep) {
if (r[en - 1].val == x) {
if (en < len) {
len = en;
memcpy(bst, r, sizeof r);
}
return;
}
if (deep >= 6) return;
for (int i = 0; i < en; i++) {
for (int u = 1; u < en; u++) {
for (int k = 1; k <= 8; k <<= 1) {
int nxtVal = r[i].val + r[u].val * k;
if (nxtVal <= x && calced[nxtVal] == false) {
calced[nxtVal] = true;
r[en].val = nxtVal;
r[en].reg1 = i;
r[en].reg2 = u;
r[en].k = k;
++en;
DFS(deep + 1);
if (nxtVal > 1) calced[nxtVal] = false;
--en;
}
}
}
}
}
int main() {
r[0].val = 0;
r[1].val = 1;
cin >> x;
calced[0] = calced[1] = true;
DFS(1);
printf("%d\n", len - 2);
for (int i = 2; i < len; i++) {
if (bst[i].reg1 == 0)
printf("lea e%cx, [%d*e%cx]\n", i + 'a' - 1, bst[i].k,
bst[i].reg2 + 'a' - 1);
else
printf("lea e%cx, [e%cx + %d*e%cx]\n", i + 'a' - 1, bst[i].reg1 + 'a' - 1,
bst[i].k, bst[i].reg2 + 'a' - 1);
}
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
There is a grid with N rows and N columns of squares. Let (i, j) be the square at the i-th row from the top and the j-th column from the left.
Each of the central (N-2) \times (N-2) squares in the grid has a black stone on it. Each of the 2N - 1 squares on the bottom side and the right side has a white stone on it.
Q queries are given. We ask you to process them in order. There are two kinds of queries. Their input format and description are as follows:
* `1 x`: Place a white stone on (1, x). After that, for each black stone between (1, x) and the first white stone you hit if you go down from (1, x), replace it with a white stone.
* `2 x`: Place a white stone on (x, 1). After that, for each black stone between (x, 1) and the first white stone you hit if you go right from (x, 1), replace it with a white stone.
How many black stones are there on the grid after processing all Q queries?
Constraints
* 3 \leq N \leq 2\times 10^5
* 0 \leq Q \leq \min(2N-4,2\times 10^5)
* 2 \leq x \leq N-1
* Queries are pairwise distinct.
Input
Input is given from Standard Input in the following format:
N Q
Query_1
\vdots
Query_Q
Output
Print how many black stones there are on the grid after processing all Q queries.
Examples
Input
5 5
1 3
2 3
1 4
2 2
1 2
Output
1
Input
200000 0
Output
39999200004
Input
176527 15
1 81279
2 22308
2 133061
1 80744
2 44603
1 170938
2 139754
2 15220
1 172794
1 159290
2 156968
1 56426
2 77429
1 97459
2 71282
Output
31159505795
### Response
```cpp
#include<bits/stdc++.h>
#define mid (l+r)/2
#define int long long
using namespace std;
int n,Q,p,q,seg[2][800001],ans;
void segadd(int nu,int u,int l,int r,int nl,int nr,int np){
if(l>nr||r<nl)return;
else if(l>=nl&&r<=nr){
seg[nu][u]=min(seg[nu][u],np);
return;
}else{
segadd(nu,u*2,l,mid,nl,nr,np),segadd(nu,u*2+1,mid+1,r,nl,nr,np);
return;
}
}
int segreq(int nu,int u,int l,int r,int np,int nx){
if(l==r){
return min(nx,seg[nu][u]);
}else{
if(np<=mid)return segreq(nu,u*2,l,mid,np,min(nx,seg[nu][u]));
else return segreq(nu,u*2+1,mid+1,r,np,min(nx,seg[nu][u]));
}
}
signed main(){
cin>>n>>Q;
for(int i=1;i<=4*n;i++)seg[0][i]=seg[1][i]=n;ans=(n-2)*(n-2);
for(int i=1;i<=Q;i++){
cin>>p>>q;
if(p==1){
int np=segreq(0,1,1,n,q,n);ans-=np-2;
segadd(1,1,1,n,1,np-1,q);
}else if(p==2){
int np=segreq(1,1,1,n,q,n);ans-=np-2;
segadd(0,1,1,n,1,np-1,q);
}
}
printf("%lld\n",ans);
return 0;
}
/*
100 4 17
10 4 7
*/
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
E: Do You Divide It? / Do you want to chop it up?
story
Mr. T has been terribly troubled by the problem of plane figures in programming contests he has participated in in the past, and has had a strong grudge against plane figures ever since.
Above all, I have mixed feelings about polygons drawn on a two-dimensional plane, so when I see a polygon, I can't help but chop it up.
When Mr. T chops a polygon, he covers the polygon with a plate with slits at intervals of 0.5 width parallel to the y-axis, and chops and discards the invisible part with the slits.
However, Mr. T does not like unilateral killing, so in order to leave the buds of recurrence in the polygon, care should be taken to make the total area of ββthe figures remaining after chopping as large as possible.
Let's find the area of ββthe figure that remains after Mr. T chops it.
problem
The two-dimensional plane has an infinite length slit in the y-axis direction, and the visible part and the invisible part are switched every 0.5 in the x-axis direction.
As shown in the figure below, a polygon consisting of N vertices continues to translate in the positive x-axis direction on this plane.
<image>
Output the area of ββthe visible part at the moment when the visible part of the polygon becomes the largest.
Input format
Give N in the first line. In the i-th line of the following N lines, the i-th vertex coordinates (x_i, y_i) in the counterclockwise direction of the polygon are given.
The following can be assumed.
* All inputs are integers
* 3 β€ N β€ 100, β10 ^ 3 β€ x_i, y_i β€ 10 ^ 3
* Given polygons do not share edges or vertices with anything other than adjacent line segments.
* The three consecutive vertices of a given polygon are not on the same straight line
Output format
Output the visible area in one line at the moment when the visible part of the given polygon becomes the largest. Absolute error and relative error are allowed up to 10 ^ {-5}.
Input example 1
6
0 0
-1 -2
3 -2
2 0
3 2
-1 2
Output example 1
6.000000000
Input example 2
Five
0 0
twenty two
4 -2
4 2
twenty two
Output example 2
6.50000000
Example
Input
6
0 0
-1 -2
3 -2
2 0
3 2
-1 2
Output
6.000000000
### Response
```cpp
#include <string>
#include <vector>
#include <algorithm>
#include <numeric>
#include <set>
#include <map>
#include <queue>
#include <iostream>
#include <sstream>
#include <cstdio>
#include <cmath>
#include <ctime>
#include <cstring>
#include <cctype>
#include <cassert>
#include <limits>
#include <functional>
#define rep(i,n) for(int (i)=0;(i)<(int)(n);++(i))
#define rer(i,l,u) for(int (i)=(int)(l);(i)<=(int)(u);++(i))
#define reu(i,l,u) for(int (i)=(int)(l);(i)<(int)(u);++(i))
#if defined(_MSC_VER) || __cplusplus > 199711L
#define aut(r,v) auto r = (v)
#else
#define aut(r,v) __typeof(v) r = (v)
#endif
#define each(it,o) for(aut(it, (o).begin()); it != (o).end(); ++ it)
#define all(o) (o).begin(), (o).end()
#define pb(x) push_back(x)
#define mp(x,y) make_pair((x),(y))
#define mset(m,v) memset(m,v,sizeof(m))
#define INF 0x3f3f3f3f
#define INFL 0x3f3f3f3f3f3f3f3fLL
using namespace std;
typedef vector<int> vi; typedef pair<int,int> pii; typedef vector<pair<int,int> > vpii; typedef long long ll;
template<typename T, typename U> inline void amin(T &x, U y) { if(y < x) x = y; }
template<typename T, typename U> inline void amax(T &x, U y) { if(x < y) x = y; }
double area(int x1, int x2, int y1, int y2) {
if(x1 == x2) return 0;
if(x1 > x2) return -area(x2, x1, y2, y1);
int w = x2 - x1, h = y2 - y1;
double s = (double)h / w;
double res = 0;
reu(x, x1, x2) if(x % 2 != 0) {
double yl = y1 + s * (x - x1);
double yr = y1 + s * (x + 1 - x1);
res += (yl + yr) * 1 / 2.;
}
return res;
}
int main() {
int N;
scanf("%d", &N);
vi x(N), y(N);
rep(i, N) scanf("%d%d", &x[i], &y[i]), x[i] *= 2, y[i] *= 2;
double ans = 0;
rep(t, 2) {
double a = 0;
rep(i, N)
a += area(x[i], x[(i+1)%N], y[i], y[(i+1)%N]);
// cerr << t << ": " << abs(a) / 4 << endl;
amax(ans, abs(a));
rep(i, N)
x[i] += 1;
}
ans /= 4;
printf("%.10f\n", ans);
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
After a probationary period in the game development company of IT City Petya was included in a group of the programmers that develops a new turn-based strategy game resembling the well known "Heroes of Might & Magic". A part of the game is turn-based fights of big squadrons of enemies on infinite fields where every cell is in form of a hexagon.
Some of magic effects are able to affect several field cells at once, cells that are situated not farther than n cells away from the cell in which the effect was applied. The distance between cells is the minimum number of cell border crosses on a path from one cell to another.
It is easy to see that the number of cells affected by a magic effect grows rapidly when n increases, so it can adversely affect the game performance. That's why Petya decided to write a program that can, given n, determine the number of cells that should be repainted after effect application, so that game designers can balance scale of the effects and the game performance. Help him to do it. Find the number of hexagons situated not farther than n cells away from a given cell.
<image>
Input
The only line of the input contains one integer n (0 β€ n β€ 109).
Output
Output one integer β the number of hexagons situated not farther than n cells away from a given cell.
Examples
Input
2
Output
19
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 100;
int main() {
ios_base ::sync_with_stdio(false);
long long n;
cin >> n;
long long ans = 1 + 3 * (n * (n + 1));
cout << ans;
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
You are given an array a, consisting of n positive integers.
Let's call a concatenation of numbers x and y the number that is obtained by writing down numbers x and y one right after another without changing the order. For example, a concatenation of numbers 12 and 3456 is a number 123456.
Count the number of ordered pairs of positions (i, j) (i β j) in array a such that the concatenation of a_i and a_j is divisible by k.
Input
The first line contains two integers n and k (1 β€ n β€ 2 β
10^5, 2 β€ k β€ 10^9).
The second line contains n integers a_1, a_2, ..., a_n (1 β€ a_i β€ 10^9).
Output
Print a single integer β the number of ordered pairs of positions (i, j) (i β j) in array a such that the concatenation of a_i and a_j is divisible by k.
Examples
Input
6 11
45 1 10 12 11 7
Output
7
Input
4 2
2 78 4 10
Output
12
Input
5 2
3 7 19 3 3
Output
0
Note
In the first example pairs (1, 2), (1, 3), (2, 3), (3, 1), (3, 4), (4, 2), (4, 3) suffice. They produce numbers 451, 4510, 110, 1045, 1012, 121, 1210, respectively, each of them is divisible by 11.
In the second example all n(n - 1) pairs suffice.
In the third example no pair is sufficient.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
long long a[n];
long long len[n];
unordered_map<int, int> rems[11];
bool validlen[11];
int temp;
for (int i = 0; i < 11; ++i) {
validlen[i] = false;
}
for (int i = 0; i < n; ++i) {
cin >> a[i];
temp = a[i];
len[i] = 0;
for (int r = 0; r < 10; ++r) {
if (temp > 0) {
len[i] += 1;
temp /= 10;
} else {
break;
}
}
validlen[len[i]] = true;
a[i] = a[i] % k;
}
long long pow10mod[11];
long long pow10 = 1;
for (int i = 0; i < 11; ++i) {
pow10mod[i] = (pow10 % k);
pow10 *= 10;
}
for (int j = 0; j < 11; ++j) {
if (!validlen[j]) continue;
for (int i = 0; i < n; ++i) {
rems[j][(a[i] * pow10mod[j]) % k] += 1;
}
}
long long ans = 0;
for (int i = 0; i < n; ++i) {
ans += (long long)rems[len[i]][(k - a[i]) % k];
if ((a[i] * pow10mod[len[i]]) % k == (k - a[i]) % k) {
ans -= 1;
}
}
cout << ans << "\n";
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
Once Vasya and Petya assembled a figure of m cubes, each of them is associated with a number between 0 and m - 1 (inclusive, each number appeared exactly once). Let's consider a coordinate system such that the OX is the ground, and the OY is directed upwards. Each cube is associated with the coordinates of its lower left corner, these coordinates are integers for each cube.
The figure turned out to be stable. This means that for any cube that is not on the ground, there is at least one cube under it such that those two cubes touch by a side or a corner. More formally, this means that for the cube with coordinates (x, y) either y = 0, or there is a cube with coordinates (x - 1, y - 1), (x, y - 1) or (x + 1, y - 1).
Now the boys want to disassemble the figure and put all the cubes in a row. In one step the cube is removed from the figure and being put to the right of the blocks that have already been laid. The guys remove the cubes in such order that the figure remains stable. To make the process more interesting, the guys decided to play the following game. The guys take out the cubes from the figure in turns. It is easy to see that after the figure is disassembled, the integers written on the cubes form a number, written in the m-ary positional numerical system (possibly, with a leading zero). Vasya wants the resulting number to be maximum possible, and Petya, on the contrary, tries to make it as small as possible. Vasya starts the game.
Your task is to determine what number is formed after the figure is disassembled, if the boys play optimally. Determine the remainder of the answer modulo 109 + 9.
Input
The first line contains number m (2 β€ m β€ 105).
The following m lines contain the coordinates of the cubes xi, yi ( - 109 β€ xi β€ 109, 0 β€ yi β€ 109) in ascending order of numbers written on them. It is guaranteed that the original figure is stable.
No two cubes occupy the same place.
Output
In the only line print the answer to the problem.
Examples
Input
3
2 1
1 0
0 1
Output
19
Input
5
0 0
0 1
0 2
0 3
0 4
Output
2930
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1e9 + 9;
const int maxn = 100100;
struct BOX {
int x, y, id;
} box[maxn];
int n;
map<pair<int, int>, int> mPI;
set<pair<int, int> > Pt;
set<int> St;
bool isST(int id) {
int x = box[id].x;
int y = box[id].y;
pair<int, int> tp;
tp = make_pair(x - 1, y + 1);
if (Pt.count(tp) == 1) {
if (Pt.count(make_pair(x - 2, y)) || Pt.count(make_pair(x - 1, y)))
;
else
return false;
}
tp = make_pair(x, y + 1);
if (Pt.count(tp) == 1) {
if (Pt.count(make_pair(x - 1, y)) || Pt.count(make_pair(x + 1, y)))
;
else
return false;
}
tp = make_pair(x + 1, y + 1);
if (Pt.count(tp) == 1) {
if (Pt.count(make_pair(x + 1, y)) || Pt.count(make_pair(x + 2, y)))
;
else
return false;
}
return true;
}
void checkST(int id) {
if (isST(id)) {
St.insert(id);
} else {
if (St.count(id)) St.erase(id);
}
}
void checkround(int id) {
int x = box[id].x;
int y = box[id].y;
checkST(id);
for (int i = -1; i <= 1; i++) {
for (int j = -1; j <= 1; j += 2) {
int nx = x + i, ny = y + j;
pair<int, int> tp = make_pair(nx, ny);
if (Pt.count(tp) == 1) {
int dd = mPI[tp];
checkST(dd);
}
}
}
}
void Remove(int id) {
int x = box[id].x;
int y = box[id].y;
Pt.erase(make_pair(x, y));
St.erase(id);
for (int i = -1; i <= 1; i++) {
for (int j = -1; j <= 1; j += 2) {
int nx = x + i, ny = y + j;
pair<int, int> tp = make_pair(nx, ny);
if (Pt.count(tp) == 1) {
int ID = mPI[tp];
checkround(ID);
}
}
}
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
box[i] = (BOX){x, y, i};
mPI[make_pair(x, y)] = i;
Pt.insert(make_pair(x, y));
}
int mxid = 0, miid = 0;
for (int i = 0; i < n; i++) {
if (isST(i)) {
St.insert(i);
mxid = max(mxid, i);
miid = min(miid, i);
}
}
vector<int> vi;
for (int loop = 0; loop < n; loop++) {
if (loop % 2 == 0) {
vi.push_back(mxid);
Remove(mxid);
} else {
vi.push_back(miid);
Remove(miid);
}
if (loop == n - 1) continue;
miid = *St.begin();
mxid = *(--St.end());
}
long long int ans = 0, base = 1;
for (int sz = vi.size(), i = sz - 1; i >= 0; i--) {
ans = (ans + base * vi[i] % mod) % mod;
base = (base * n) % mod;
}
cout << ans % mod << endl;
return 0;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
We have an H-by-W matrix. Let a_{ij} be the element at the i-th row from the top and j-th column from the left. In this matrix, each a_{ij} is a lowercase English letter.
Snuke is creating another H-by-W matrix, A', by freely rearranging the elements in A. Here, he wants to satisfy the following condition:
* Every row and column in A' can be read as a palindrome.
Determine whether he can create a matrix satisfying the condition.
Constraints
* 1 β€ H, W β€ 100
* a_{ij} is a lowercase English letter.
Input
Input is given from Standard Input in the following format:
H W
a_{11}a_{12}...a_{1W}
:
a_{H1}a_{H2}...a_{HW}
Output
If Snuke can create a matrix satisfying the condition, print `Yes`; otherwise, print `No`.
Examples
Input
3 4
aabb
aabb
aacc
Output
Yes
Input
2 2
aa
bb
Output
No
Input
5 1
t
w
e
e
t
Output
Yes
Input
2 5
abxba
abyba
Output
No
Input
1 1
z
Output
Yes
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
int main() {
int H,W;
cin >> H >> W;
vector<int> cnt(26, 0);
for(int i=0; i<H; i++) {
string s;
cin >> s;
for(int j=0; j<W; j++) {
cnt[s[j] - 'a']++;
}
}
string yes ="Yes" ;
string no = "No";
int odd = 0;
for(int i=0; i < cnt.size(); i++)
if(cnt[i] % 2 == 1) odd++;
if(odd != (H%2) * (W%2)) {
cout << no << endl;
return 0;
}
for(auto &c : cnt) c /= 2;
//for(auto &c :cnt) cout << c << endl;
int two = H * W - 4 * (H/2) * (W/2) - (H%2) * (W%2);
two /= 2;
odd = 0;
for(auto c: cnt) {
if(c % 2 == 1)
odd++;
}
if(odd <= two) {
cout << yes << endl;
}
else cout << no << endl;
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
You have array a1, a2, ..., an. Segment [l, r] (1 β€ l β€ r β€ n) is good if ai = ai - 1 + ai - 2, for all i (l + 2 β€ i β€ r).
Let's define len([l, r]) = r - l + 1, len([l, r]) is the length of the segment [l, r]. Segment [l1, r1], is longer than segment [l2, r2], if len([l1, r1]) > len([l2, r2]).
Your task is to find a good segment of the maximum length in array a. Note that a segment of length 1 or 2 is always good.
Input
The first line contains a single integer n (1 β€ n β€ 105) β the number of elements in the array. The second line contains integers: a1, a2, ..., an (0 β€ ai β€ 109).
Output
Print the length of the longest good segment in array a.
Examples
Input
10
1 2 3 5 8 13 21 34 55 89
Output
10
Input
5
1 1 1 1 1
Output
2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void adskiy_razgon() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
const int mxN = 1e+9 + 7;
const long long INF = 1e+18 + 7;
long long nod(long long a, long long b) {
if (b > a) {
swap(a, b);
}
while (b > 0) {
a %= b;
swap(a, b);
}
return a;
}
long long nok(long long a, long long b) { return a * b / nod(a, b); }
void sp(long long a, double b) { cout << fixed << setprecision(a) << b; }
long long binpow(long long a, long long n) {
if (n == 0) {
return 1;
}
if (n % 2 == 1) {
return binpow(a, n - 1) * a;
} else {
long long b = binpow(a, n / 2);
return b * b;
}
}
int a[100000];
void solve() {
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
if (n == 1) {
cout << 1;
return;
}
int cnt = 2, ans = 0;
for (int i = 2; i < n; ++i) {
if (a[i] == a[i - 1] + a[i - 2]) {
cnt++;
} else {
cnt = 2;
}
ans = max(ans, cnt);
}
ans = max(ans, cnt);
cout << ans;
}
int main() {
adskiy_razgon();
long long t = 1;
for (int i = 1; i <= t; ++i) {
solve();
}
return 0;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
Nezzar's favorite digit among 1,β¦,9 is d. He calls a positive integer lucky if d occurs at least once in its decimal representation.
Given q integers a_1,a_2,β¦,a_q, for each 1 β€ i β€ q Nezzar would like to know if a_i can be equal to a sum of several (one or more) lucky numbers.
Input
The first line contains a single integer t (1 β€ t β€ 9) β the number of test cases.
The first line of each test case contains two integers q and d (1 β€ q β€ 10^4, 1 β€ d β€ 9).
The second line of each test case contains q integers a_1,a_2,β¦,a_q (1 β€ a_i β€ 10^9).
Output
For each integer in each test case, print "YES" in a single line if a_i can be equal to a sum of lucky numbers. Otherwise, print "NO".
You can print letters in any case (upper or lower).
Example
Input
2
3 7
24 25 27
10 7
51 52 53 54 55 56 57 58 59 60
Output
YES
NO
YES
YES
YES
NO
YES
YES
YES
YES
YES
YES
NO
Note
In the first test case, 24 = 17 + 7, 27 itself is a lucky number, 25 cannot be equal to a sum of lucky numbers.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
bool check(long int n,int d)
{
int temp=n%10;
while(n>0)
{
if(temp==d)
return 0;
n=n/10;
temp=n%d;
}
return 1;
}
void solve(long int n,int d)
{
if(n<=0){
cout<<"NO\n";
return;
}
if(n%d==0)
{
cout<<"YES\n";
return;
}
else
{
solve(n-10,d);
}
}
int main(void) {
// your code goes here
int t;
cin>>t;
while(t--)
{
int q,d,i;
cin>>q>>d;
long int a[q];
for(i=0;i<q;i++)
{
cin>>a[i];
if(a[i]>=(d*10) or a[i]%d==0)
{
cout<<"YES\n";
}
else
{
if(!check(a[i],d))
{
cout<<"YES\n";
}
else
{
solve(a[i]-d,d);
}
}
}
// cout<<"\n";
}
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
Notice that the memory limit is non-standard.
Recently Arthur and Sasha have studied correct bracket sequences. Arthur understood this topic perfectly and become so amazed about correct bracket sequences, so he even got himself a favorite correct bracket sequence of length 2n. Unlike Arthur, Sasha understood the topic very badly, and broke Arthur's favorite correct bracket sequence just to spite him.
All Arthur remembers about his favorite sequence is for each opening parenthesis ('(') the approximate distance to the corresponding closing one (')'). For the i-th opening bracket he remembers the segment [li, ri], containing the distance to the corresponding closing bracket.
Formally speaking, for the i-th opening bracket (in order from left to right) we know that the difference of its position and the position of the corresponding closing bracket belongs to the segment [li, ri].
Help Arthur restore his favorite correct bracket sequence!
Input
The first line contains integer n (1 β€ n β€ 600), the number of opening brackets in Arthur's favorite correct bracket sequence.
Next n lines contain numbers li and ri (1 β€ li β€ ri < 2n), representing the segment where lies the distance from the i-th opening bracket and the corresponding closing one.
The descriptions of the segments are given in the order in which the opening brackets occur in Arthur's favorite sequence if we list them from left to right.
Output
If it is possible to restore the correct bracket sequence by the given data, print any possible choice.
If Arthur got something wrong, and there are no sequences corresponding to the given information, print a single line "IMPOSSIBLE" (without the quotes).
Examples
Input
4
1 1
1 1
1 1
1 1
Output
()()()()
Input
3
5 5
3 3
1 1
Output
((()))
Input
3
5 5
3 3
2 2
Output
IMPOSSIBLE
Input
3
2 3
1 4
1 4
Output
(())()
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int mx = 600 + 10;
const long long mod = 1e9 + 7;
mt19937 mtrand(time(0));
int n, m;
int l[mx], r[mx], p[mx];
char s[mx * 2];
bool check() {
for (int i = n; i >= 1; --i) {
if (l[i] == 1)
p[i] = 1;
else {
int fg = 0, sum = 0;
for (int j = i + 1; j <= n;) {
if (sum + p[j] + 2 >= l[i] && sum + p[j] + 2 <= r[i]) {
p[i] = sum + p[j] + 2;
fg = 1;
break;
}
sum += p[j] + 1;
j += (p[j] + 1) / 2;
}
if (!fg) return false;
}
}
for (int i = 0; i < 2 * n; ++i) s[i] = '0';
for (int i = 0, id = 1; i < 2 * n; ++i) {
if (s[i] != '0') continue;
s[i] = '(', s[i + p[id]] = ')';
++id;
}
s[2 * n] = '\0';
puts(s);
return true;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d%d", &l[i], &r[i]);
}
if (!check()) puts("IMPOSSIBLE");
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
You are given a string s consisting of characters "1", "0", and "?". The first character of s is guaranteed to be "1". Let m be the number of characters in s.
Count the number of ways we can choose a pair of integers a, b that satisfies the following:
* 1 β€ a < b < 2^m
* When written without leading zeros, the base-2 representations of a and b are both palindromes.
* The base-2 representation of bitwise XOR of a and b matches the pattern s. We say that t matches s if the lengths of t and s are the same and for every i, the i-th character of t is equal to the i-th character of s, or the i-th character of s is "?".
Compute this count modulo 998244353.
Input
The first line contains a single string s (1 β€ |s| β€ 1 000). s consists only of characters "1", "0" and "?". It is guaranteed that the first character of s is a "1".
Output
Print a single integer, the count of pairs that satisfy the conditions modulo 998244353.
Examples
Input
10110
Output
3
Input
1?0???10
Output
44
Input
1?????????????????????????????????????
Output
519569202
Input
1
Output
0
Note
For the first example, the pairs in base-2 are (111, 10001), (11, 10101), (1001, 11111).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 998244353;
string s;
vector<int> g[2010], dg[2010];
int co[2010];
long long ans = 0, res;
bool ok;
void dfs(int pos, int now) {
if (!ok) return;
co[pos] = now;
for (int i = 0; i < g[pos].size(); i++) {
if (co[g[pos][i]] != -1) {
if (co[g[pos][i]] != now) {
ok = false;
return;
}
continue;
}
dfs(g[pos][i], now);
}
for (int i = 0; i < dg[pos].size(); i++) {
if (co[dg[pos][i]] != -1) {
if (co[dg[pos][i]] != (now ^ 1)) {
ok = false;
return;
}
continue;
}
dfs(dg[pos][i], now ^ 1);
}
}
int main() {
cin >> s;
for (int len = s.size() - 1; len > 0; len--) {
ok = true;
for (int i = 0; i < 2005; i++) {
co[i] = -1;
g[i].clear();
dg[i].clear();
}
for (int i = 0; i < s.size() / 2; i++) {
g[i].push_back(s.size() - i - 1);
g[s.size() - i - 1].push_back(i);
}
for (int i = 0; i < len / 2; i++) {
g[i + s.size()].push_back(len - i - 1 + s.size());
g[len - i - 1 + s.size()].push_back(i + s.size());
}
int f1 = -1, f0 = -1, l1 = -1, l0 = -1;
for (int i = 0; i < s.size() - len; i++) {
if (s[i] == '1') {
if (f1 == -1) {
f1 = l1 = i;
continue;
}
g[i].push_back(l1);
g[l1].push_back(i);
l1 = i;
}
if (s[i] == '0') {
if (f0 == -1) {
f0 = l0 = i;
continue;
}
g[i].push_back(l0);
g[l0].push_back(i);
l0 = i;
}
}
if (l1 > -1 && l0 > -1) {
dg[l1].push_back(l0);
dg[l0].push_back(l1);
}
for (int i = s.size() - len, j = 0; i < s.size(); i++, j++) {
if (s[i] == '1') {
dg[i].push_back(j + s.size());
dg[j + s.size()].push_back(i);
}
if (s[i] == '0') {
g[i].push_back(j + s.size());
g[j + s.size()].push_back(i);
}
}
g[s.size()].push_back(0);
g[0].push_back(s.size());
int all = 0;
for (int i = 0; i < s.size() + len; i++) {
if (co[i] == -1) {
dfs(i, 0);
all++;
}
}
if (!ok) continue;
res = 1;
for (int i = 0; i < all - 1; i++) res = res * 2 % MOD;
ans = (ans + res) % MOD;
}
cout << ans << endl;
return 0;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
From beginning till end, this message has been waiting to be conveyed.
For a given unordered multiset of n lowercase English letters ("multi" means that a letter may appear more than once), we treat all letters as strings of length 1, and repeat the following operation n - 1 times:
* Remove any two elements s and t from the set, and add their concatenation s + t to the set.
The cost of such operation is defined to be <image>, where f(s, c) denotes the number of times character c appears in string s.
Given a non-negative integer k, construct any valid non-empty set of no more than 100 000 letters, such that the minimum accumulative cost of the whole process is exactly k. It can be shown that a solution always exists.
Input
The first and only line of input contains a non-negative integer k (0 β€ k β€ 100 000) β the required minimum cost.
Output
Output a non-empty string of no more than 100 000 lowercase English letters β any multiset satisfying the requirements, concatenated to be a string.
Note that the printed string doesn't need to be the final concatenated string. It only needs to represent an unordered multiset of letters.
Examples
Input
12
Output
abababab
Input
3
Output
codeforces
Note
For the multiset {'a', 'b', 'a', 'b', 'a', 'b', 'a', 'b'}, one of the ways to complete the process is as follows:
* {"ab", "a", "b", "a", "b", "a", "b"}, with a cost of 0;
* {"aba", "b", "a", "b", "a", "b"}, with a cost of 1;
* {"abab", "a", "b", "a", "b"}, with a cost of 1;
* {"abab", "ab", "a", "b"}, with a cost of 0;
* {"abab", "aba", "b"}, with a cost of 1;
* {"abab", "abab"}, with a cost of 1;
* {"abababab"}, with a cost of 8.
The total cost is 12, and it can be proved to be the minimum cost of the process.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int SIGMA = 26;
int k;
vector<int> wynik;
void wczytaj_dane() { cin >> k; }
void rozwiaz() {
if (k == 0) wynik.push_back(1);
while (k > 0) {
int suma = 0, n = 1;
while (suma + n <= k) {
suma += n;
n++;
}
k -= suma;
wynik.push_back(n);
}
}
void wypisz_wynik() {
assert(int((wynik).size()) <= SIGMA);
for (int i = 0; i < (int((wynik).size())); i++)
while (wynik[i]--) cout << char(int('a') + i);
cout << '\n';
}
void zrob_test() {
wczytaj_dane();
rozwiaz();
wypisz_wynik();
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
zrob_test();
return 0;
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
Mr. Schwarz was a famous powerful pro wrestler. He starts a part time job as a warehouseman. His task is to move a cargo to a goal by repeatedly pushing the cargo in the warehouse, of course, without breaking the walls and the pillars of the warehouse.
There may be some pillars in the warehouse. Except for the locations of the pillars, the floor of the warehouse is paved with square tiles whose size fits with the cargo. Each pillar occupies the same area as a tile.
<image>
Initially, the cargo is on the center of a tile. With one push, he can move the cargo onto the center of an adjacent tile if he is in proper position. The tile onto which he will move the cargo must be one of (at most) four tiles (i.e., east, west, north or south) adjacent to the tile where the cargo is present.
To push, he must also be on the tile adjacent to the present tile. He can only push the cargo in the same direction as he faces to it and he cannot pull it. So, when the cargo is on the tile next to a wall (or a pillar), he can only move it along the wall (or the pillar). Furthermore, once he places it on a corner tile, he cannot move it anymore.
He can change his position, if there is a path to the position without obstacles (such as the cargo and pillars) in the way. The goal is not an obstacle. In addition, he can move only in the four directions (i.e., east, west, north or south) and change his direction only at the center of a tile.
As he is not so young, he wants to save his energy by keeping the number of required pushes as small as possible. But he does not mind the count of his pedometer, because walking is very light exercise for him.
Your job is to write a program that outputs the minimum number of pushes required to move the cargo to the goal, if ever possible.
Input
The input consists of multiple maps, each representing the size and the arrangement of the warehouse. A map is given in the following format.
w h
d11 d12 d13 ... d1w
d21 d22 d23 ... d2w
...
dh1 dh2 dh3 ... dhw
The integers w and h are the lengths of the two sides of the floor of the warehouse in terms of widths of floor tiles. w and h are less than or equal to 7. The integer dij represents what is initially on the corresponding floor area in the following way.
0: nothing (simply a floor tile)
1: a pillar
2: the cargo
3: the goal
4: the warehouseman (Mr. Schwarz)
Each of the integers 2, 3 and 4 appears exactly once as dij in the map. Integer numbers in an input line are separated by at least one space character. The end of the input is indicated by a line containing two zeros.
Output
For each map, your program should output a line containing the minimum number of pushes. If the cargo cannot be moved to the goal, -1 should be output instead.
Example
Input
5 5
0 0 0 0 0
4 2 0 1 1
0 1 0 0 0
1 0 0 0 3
1 0 0 0 0
5 3
4 0 0 0 0
2 0 0 0 0
0 0 0 0 3
7 5
1 1 4 1 0 0 0
1 1 2 1 0 0 0
3 0 0 0 0 0 0
0 1 0 1 0 0 0
0 0 0 1 0 0 0
6 6
0 0 0 0 0 3
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 2 0 0 0 0
4 0 0 0 0 0
0 0
Output
5
-1
11
8
### Response
```cpp
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <queue>
using namespace std;
typedef pair<int, int> P;
const int dx[] = {1, 0, -1, 0};
const int dy[] = {0, 1, 0, -1};
int H, W;
int field[8][8];
bool arrive[8][8][8][8][8][8];
void init(){
memset(field, 0, sizeof(field));
memset(arrive, false, sizeof(arrive));
}
void canArrive(int bx, int by, int sx, int sy){
int tmp_field[8][8];
memset(tmp_field, 0, sizeof(tmp_field));
for(int i = 0 ; i < H ; i++){
for(int j = 0 ; j < W ; j++){
if(field[i][j] != 1) tmp_field[i][j] = 0;
else tmp_field[i][j] = field[i][j];
}
}
tmp_field[by][bx] = 2;
queue<P> que;
que.push(P(sx, sy));
while(!que.empty()){
P q = que.front(); que.pop();
arrive[by][bx][sy][sx][q.second][q.first] = true;
for(int i = 0 ; i < 4 ; i++){
int nx = q.first + dx[i], ny = q.second + dy[i];
if(nx < 0 || nx >= W || ny < 0 || ny >= H) continue;
if(tmp_field[ny][nx] != 0) continue;
if(arrive[by][bx][sy][sx][ny][nx]) continue;
que.push(P(nx, ny));
}
}
}
struct State{
int x, y, sx, sy, cost;
State(int x, int y, int sx, int sy, int cost) : x(x), y(y), sx(sx), sy(sy), cost(cost){}
};
const bool operator < (const State &a, const State &b){
return a.cost > b.cost;
}
int bfs(){
int sx, sy, bx, by;
for(int i = 0 ; i < H ; i++){
for(int j = 0 ; j < W ; j++){
if(field[i][j] == 2) bx = j, by = i;
if(field[i][j] == 4) sx = j, sy = i;
}
}
priority_queue<State> que;
que.push(State(bx, by, sx, sy, 0));
bool used[8][8][8][8];
memset(used, false, sizeof(used));
while(!que.empty()){
State p = que.top(); que.pop();
if(field[p.y][p.x] == 3) return p.cost;
if(used[p.y][p.x][p.sy][p.sx]) continue;
used[p.y][p.x][p.sy][p.sx] = true;
for(int i = 0 ; i < 4 ; i++){
int nx1, nx2, ny1, ny2;
nx1 = p.x + dx[i], ny1 = p.y + dy[i];
nx2 = p.x - dx[i], ny2 = p.y - dy[i];
if(nx1 < 0 || nx1 >= W || ny1 < 0 || ny1 >= H ||
nx2 < 0 || nx2 >= W || ny2 < 0 || ny2 >= H) continue;
if(field[ny1][nx1] == 1) continue;
if(field[ny2][nx2] == 1) continue;
if(!arrive[p.y][p.x][p.sy][p.sx][ny2][nx2]) continue;
que.push(State(nx1, ny1, nx2, ny2, p.cost+1));
}
}
return -1;
}
int main(){
while(cin >> W >> H, W|H){
init();
for(int i = 0 ; i < H ; i++)
for(int j = 0 ; j < W ; j++) cin >> field[i][j];
for(int by = 0 ; by < H ; by++){
for(int bx = 0 ; bx < W ; bx++){
if(field[by][bx] == 1) continue;
for(int sy = 0 ; sy < H ; sy++){
for(int sx = 0 ; sx < W ; sx++){
if(sy == by && sx == bx) continue;
if(field[sy][sx] == 1) continue;
canArrive(bx, by, sx, sy);
}
}
}
}
cout << bfs() << endl;
}
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
Vasya decided to learn to play chess. Classic chess doesn't seem interesting to him, so he plays his own sort of chess.
The queen is the piece that captures all squares on its vertical, horizontal and diagonal lines. If the cell is located on the same vertical, horizontal or diagonal line with queen, and the cell contains a piece of the enemy color, the queen is able to move to this square. After that the enemy's piece is removed from the board. The queen cannot move to a cell containing an enemy piece if there is some other piece between it and the queen.
There is an n Γ n chessboard. We'll denote a cell on the intersection of the r-th row and c-th column as (r, c). The square (1, 1) contains the white queen and the square (1, n) contains the black queen. All other squares contain green pawns that don't belong to anyone.
The players move in turns. The player that moves first plays for the white queen, his opponent plays for the black queen.
On each move the player has to capture some piece with his queen (that is, move to a square that contains either a green pawn or the enemy queen). The player loses if either he cannot capture any piece during his move or the opponent took his queen during the previous move.
Help Vasya determine who wins if both players play with an optimal strategy on the board n Γ n.
Input
The input contains a single number n (2 β€ n β€ 109) β the size of the board.
Output
On the first line print the answer to problem β string "white" or string "black", depending on who wins if the both players play optimally.
If the answer is "white", then you should also print two integers r and c representing the cell (r, c), where the first player should make his first move to win. If there are multiple such cells, print the one with the minimum r. If there are still multiple squares, print the one with the minimum c.
Examples
Input
2
Output
white
1 2
Input
3
Output
black
Note
In the first sample test the white queen can capture the black queen at the first move, so the white player wins.
In the second test from the statement if the white queen captures the green pawn located on the central vertical line, then it will be captured by the black queen during the next move. So the only move for the white player is to capture the green pawn located at (2, 1).
Similarly, the black queen doesn't have any other options but to capture the green pawn located at (2, 3), otherwise if it goes to the middle vertical line, it will be captured by the white queen.
During the next move the same thing happens β neither the white, nor the black queen has other options rather than to capture green pawns situated above them. Thus, the white queen ends up on square (3, 1), and the black queen ends up on square (3, 3).
In this situation the white queen has to capture any of the green pawns located on the middle vertical line, after that it will be captured by the black queen. Thus, the player who plays for the black queen wins.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
if (n % 2 == 0)
printf("white\n1 2\n");
else
printf("black\n");
return 0;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
Polycarp has invited n friends to celebrate the New Year. During the celebration, he decided to take a group photo of all his friends. Each friend can stand or lie on the side.
Each friend is characterized by two values h_i (their height) and w_i (their width). On the photo the i-th friend will occupy a rectangle h_i Γ w_i (if they are standing) or w_i Γ h_i (if they are lying on the side).
The j-th friend can be placed in front of the i-th friend on the photo if his rectangle is lower and narrower than the rectangle of the i-th friend. Formally, at least one of the following conditions must be fulfilled:
* h_j < h_i and w_j < w_i (both friends are standing or both are lying);
* w_j < h_i and h_j < w_i (one of the friends is standing and the other is lying).
For example, if n = 3, h=[3,5,3] and w=[4,4,3], then:
* the first friend can be placed in front of the second: w_1 < h_2 and h_1 < w_2 (one of the them is standing and the other one is lying);
* the third friend can be placed in front of the second: h_3 < h_2 and w_3 < w_2 (both friends are standing or both are lying).
In other cases, the person in the foreground will overlap the person in the background.
Help Polycarp for each i find any j, such that the j-th friend can be located in front of the i-th friend (i.e. at least one of the conditions above is fulfilled).
Please note that you do not need to find the arrangement of all people for a group photo. You just need to find for each friend i any other friend j who can be located in front of him. Think about it as you need to solve n separate independent subproblems.
Input
The first line contains one integer t (1 β€ t β€ 10^4) β the number of test cases. Then t test cases follow.
The first line of each test case contains one integer n (1 β€ n β€ 2 β
10^5) β the number of friends.
This is followed by n lines, each of which contains a description of the corresponding friend. Each friend is described by two integers h_i and w_i (1 β€ h_i, w_i β€ 10^9) β height and width of the i-th friend, respectively.
It is guaranteed that the sum of n over all test cases does not exceed 2 β
10^5.
Output
For each test case output n integers on a separate line, where the i-th number is the index of a friend that can be placed in front of the i-th. If there is no such friend, then output -1.
If there are several answers, output any.
Example
Input
4
3
3 4
5 4
3 3
3
1 3
2 2
3 1
4
2 2
3 1
6 3
5 4
4
2 2
2 3
1 1
4 4
Output
-1 3 -1
-1 -1 -1
-1 -1 2 2
3 3 -1 3
Note
The first test case is described in the statement.
In the third test case, the following answers are also correct:
* [-1, -1, 1, 2];
* [-1, -1, 1, 1];
* [-1, -1, 2, 1].
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define endl "\n"
#define all(v) begin(v),end(v)
#define pb push_back
#define fr first
#define sc second
#define rep(i,a,b) for(int i=a;i<b;i++)
#define pi 3.1415926536
#define dig(a) fixed<<setprecision(a)
#define fast ios_base::sync_with_stdio(false); cin.tie(NULL)
const int M = 1e9+7;
const int N = 1e6+5;
ll power(ll a, ll n) {
ll res = 1;
while (n) {
if (n % 2) {res = (res * a) % M;}
n >>= 1; a = (a * a) % M;}
return res;
}
int main(){
fast;
int test; cin>>test;
while(test--){
int n;
cin>>n;
vector<pair<pair<int,int>,int>> vp;
for(int i=0;i<n;i++){
int h,w;
cin>>h>>w;
vp.pb({{w,-h},i});
vp.pb({{h,-w},i});
}
sort(all(vp));
int minh = INT_MAX;
int ele = -1;
vector<int> ans(n,-2);
for(auto t:vp){
int h = -t.fr.sc;
int ind = t.sc;
if(h>minh){
ans[ind] = ele;
}
else if(h<minh){
minh = h;
ele = ind;
}
}
rep(i,0,n){
cout<<ans[i]+1<<" ";
}
cout<<endl;
}
return 0;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
Iahub and his friend Floyd have started painting a wall. Iahub is painting the wall red and Floyd is painting it pink. You can consider the wall being made of a very large number of bricks, numbered 1, 2, 3 and so on.
Iahub has the following scheme of painting: he skips x - 1 consecutive bricks, then he paints the x-th one. That is, he'll paint bricks x, 2Β·x, 3Β·x and so on red. Similarly, Floyd skips y - 1 consecutive bricks, then he paints the y-th one. Hence he'll paint bricks y, 2Β·y, 3Β·y and so on pink.
After painting the wall all day, the boys observed that some bricks are painted both red and pink. Iahub has a lucky number a and Floyd has a lucky number b. Boys wonder how many bricks numbered no less than a and no greater than b are painted both red and pink. This is exactly your task: compute and print the answer to the question.
Input
The input will have a single line containing four integers in this order: x, y, a, b. (1 β€ x, y β€ 1000, 1 β€ a, b β€ 2Β·109, a β€ b).
Output
Output a single integer β the number of bricks numbered no less than a and no greater than b that are painted both red and pink.
Examples
Input
2 3 6 18
Output
3
Note
Let's look at the bricks from a to b (a = 6, b = 18). The bricks colored in red are numbered 6, 8, 10, 12, 14, 16, 18. The bricks colored in pink are numbered 6, 9, 12, 15, 18. The bricks colored in both red and pink are numbered with 6, 12 and 18.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int main() {
int x, y, a, b;
scanf("%d%d%d%d", &x, &y, &a, &b);
int maxone = x * y / gcd(x, y);
if (a % maxone == 0)
printf("%d\n", b / maxone - a / maxone + 1);
else
printf("%d\n", b / maxone - a / maxone);
return 0;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
Bob is a duck. He wants to get to Alice's nest, so that those two can duck!
<image> Duck is the ultimate animal! (Image courtesy of See Bang)
The journey can be represented as a straight line, consisting of n segments. Bob is located to the left of the first segment, while Alice's nest is on the right of the last segment. Each segment has a length in meters, and also terrain type: grass, water or lava.
Bob has three movement types: swimming, walking and flying. He can switch between them or change his direction at any point in time (even when he is located at a non-integer coordinate), and doing so doesn't require any extra time. Bob can swim only on the water, walk only on the grass and fly over any terrain. Flying one meter takes 1 second, swimming one meter takes 3 seconds, and finally walking one meter takes 5 seconds.
Bob has a finite amount of energy, called stamina. Swimming and walking is relaxing for him, so he gains 1 stamina for every meter he walks or swims. On the other hand, flying is quite tiring, and he spends 1 stamina for every meter flown. Staying in place does not influence his stamina at all. Of course, his stamina can never become negative. Initially, his stamina is zero.
What is the shortest possible time in which he can reach Alice's nest?
Input
The first line contains a single integer n (1 β€ n β€ 10^5) β the number of segments of terrain.
The second line contains n integers l_1, l_2, ..., l_n (1 β€ l_i β€ 10^{12}). The l_i represents the length of the i-th terrain segment in meters.
The third line contains a string s consisting of n characters "G", "W", "L", representing Grass, Water and Lava, respectively.
It is guaranteed that the first segment is not Lava.
Output
Output a single integer t β the minimum time Bob needs to reach Alice.
Examples
Input
1
10
G
Output
30
Input
2
10 10
WL
Output
40
Input
2
1 2
WL
Output
8
Input
3
10 10 10
GLW
Output
80
Note
In the first sample, Bob first walks 5 meters in 25 seconds. Then he flies the remaining 5 meters in 5 seconds.
In the second sample, Bob first swims 10 meters in 30 seconds. Then he flies over the patch of lava for 10 seconds.
In the third sample, the water pond is much smaller. Bob first swims over the water pond, taking him 3 seconds. However, he cannot fly over the lava just yet, as he only has one stamina while he needs two. So he swims back for half a meter, and then half a meter forward, taking him 3 seconds in total. Now he has 2 stamina, so he can spend 2 seconds flying over the lava.
In the fourth sample, he walks for 50 seconds, flies for 10 seconds, swims for 15 seconds, and finally flies for 5 seconds.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
inline char get(void) {
static char buf[100000], *S = buf, *T = buf;
if (S == T) {
T = (S = buf) + fread(buf, 1, 100000, stdin);
if (T == S) return EOF;
}
return *S++;
}
inline void read(int& x) {
static char c;
x = 0;
for (c = get(); c < '0' || c > '9'; c = get())
;
for (; c >= '0' && c <= '9'; c = get()) x = x * 10 + c - '0';
}
const int M = 1000 * 1000 + 10;
char s[M];
int n;
long long le[M];
long long re = 0;
long long cal() {
long long an = 0;
long long water = 0, grass = 0;
for (int i = 0; i < n; ++i) {
if (s[i] == 'G')
an += 5ll * le[i], re += le[i], grass += le[i] * 2;
else if (s[i] == 'W')
an += 3ll * le[i], re += le[i], water += le[i];
else {
an += le[i], re -= le[i];
if (re < 0) {
if (water)
an -= re * 3;
else
an -= re * 5;
re = 0;
}
}
grass = (grass < re ? grass : re);
}
an -= 2 * grass;
an -= re - grass;
return an;
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 0; i < n; ++i) cin >> le[i];
cin >> s;
cout << cal() << endl;
return 0;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
One day student Vasya was sitting on a lecture and mentioned a string s1s2... sn, consisting of letters "a", "b" and "c" that was written on his desk. As the lecture was boring, Vasya decided to complete the picture by composing a graph G with the following properties:
* G has exactly n vertices, numbered from 1 to n.
* For all pairs of vertices i and j, where i β j, there is an edge connecting them if and only if characters si and sj are either equal or neighbouring in the alphabet. That is, letters in pairs "a"-"b" and "b"-"c" are neighbouring, while letters "a"-"c" are not.
Vasya painted the resulting graph near the string and then erased the string. Next day Vasya's friend Petya came to a lecture and found some graph at his desk. He had heard of Vasya's adventure and now he wants to find out whether it could be the original graph G, painted by Vasya. In order to verify this, Petya needs to know whether there exists a string s, such that if Vasya used this s he would produce the given graph G.
Input
The first line of the input contains two integers n and m <image> β the number of vertices and edges in the graph found by Petya, respectively.
Each of the next m lines contains two integers ui and vi (1 β€ ui, vi β€ n, ui β vi) β the edges of the graph G. It is guaranteed, that there are no multiple edges, that is any pair of vertexes appear in this list no more than once.
Output
In the first line print "Yes" (without the quotes), if the string s Petya is interested in really exists and "No" (without the quotes) otherwise.
If the string s exists, then print it on the second line of the output. The length of s must be exactly n, it must consist of only letters "a", "b" and "c" only, and the graph built using this string must coincide with G. If there are multiple possible answers, you may print any of them.
Examples
Input
2 1
1 2
Output
Yes
aa
Input
4 3
1 2
1 3
1 4
Output
No
Note
In the first sample you are given a graph made of two vertices with an edge between them. So, these vertices can correspond to both the same and adjacent letters. Any of the following strings "aa", "ab", "ba", "bb", "bc", "cb", "cc" meets the graph's conditions.
In the second sample the first vertex is connected to all three other vertices, but these three vertices are not connected with each other. That means that they must correspond to distinct letters that are not adjacent, but that is impossible as there are only two such letters: a and c.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const string nameFiles = "";
void error(vector<string>::iterator) {}
template <typename T, typename... Args>
void error(vector<string>::iterator cur_var, T a, Args... args) {
cerr << cur_var->substr((*cur_var)[0] == ' ') << " = " << a << endl;
error(++cur_var, args...);
}
vector<string> split(string const& str, char c) {
vector<string> res;
stringstream ss(str);
string x;
while (getline(ss, x, c)) res.emplace_back(x);
return move(res);
}
vector<bool> used(1000, false);
void dfs() {}
int main() {
ios_base::sync_with_stdio(false);
if (!nameFiles.empty()) {
freopen((nameFiles + ".in").c_str(), "r", stdin);
freopen((nameFiles + ".out").c_str(), "w", stdout);
}
int n, m;
cin >> n >> m;
vector<vector<int>> a(n, vector<int>(n, 0));
int x, y;
for (int i = 0; i < m; ++i) {
cin >> x >> y;
x--, y--;
a[x][y] = 1;
a[y][x] = 1;
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (i == j) continue;
for (int k = 0; k < n; ++k) {
if (j == k || i == k) continue;
if (a[i][j] + a[j][k] + a[i][k] == 0) {
cout << "No" << endl;
return 0;
}
}
}
}
vector<char> res(n, 0);
queue<int> q;
q.push(0);
for (int i = 0; i < n; ++i) {
if (q.empty()) {
for (int j = 0; j < n; ++j)
if (!used[j]) {
q.push(j);
break;
}
if (q.empty()) break;
}
int cur = q.front();
used[cur] = true;
q.pop();
for (int j = 0; j < n; ++j) {
if (cur == j) continue;
if (a[cur][j] == 0) {
char inv = 'c';
if (res[cur] == 0) {
res[cur] = 'a';
} else if (res[cur] == 'c')
inv = 'a';
if (res[j] == 0) {
res[j] = inv;
q.push(j);
} else if (res[j] != inv) {
cout << "No" << endl;
return 0;
}
}
}
}
for (int i = 0; i < n; ++i)
if (res[i] == 0) res[i] = 'b';
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) {
if (i == j) continue;
if (a[i][j] == 0) {
if (!((res[i] == 'a' && res[j] == 'c') ||
(res[i] == 'c' && res[j] == 'a'))) {
cout << "NO" << endl;
return 0;
}
} else if (((res[i] == 'a' && res[j] == 'c') ||
(res[i] == 'c' && res[j] == 'a'))) {
cout << "NO" << endl;
return 0;
}
}
cout << "Yes" << endl;
for (char c : res) cout << c;
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
You are given a string s consisting of exactly n characters, and each character is either '0', '1' or '2'. Such strings are called ternary strings.
Your task is to replace minimum number of characters in this string with other characters to obtain a balanced ternary string (balanced ternary string is a ternary string such that the number of characters '0' in this string is equal to the number of characters '1', and the number of characters '1' (and '0' obviously) is equal to the number of characters '2').
Among all possible balanced ternary strings you have to obtain the lexicographically (alphabetically) smallest.
Note that you can neither remove characters from the string nor add characters to the string. Also note that you can replace the given characters only with characters '0', '1' and '2'.
It is guaranteed that the answer exists.
Input
The first line of the input contains one integer n (3 β€ n β€ 3 β
10^5, n is divisible by 3) β the number of characters in s.
The second line contains the string s consisting of exactly n characters '0', '1' and '2'.
Output
Print one string β the lexicographically (alphabetically) smallest balanced ternary string which can be obtained from the given one with minimum number of replacements.
Because n is divisible by 3 it is obvious that the answer exists. And it is obvious that there is only one possible answer.
Examples
Input
3
121
Output
021
Input
6
000000
Output
001122
Input
6
211200
Output
211200
Input
6
120110
Output
120120
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long MILLER_RABIN = 3215031751;
const long double PI = acos(-1);
void solve() {
int n;
cin >> n;
string s;
cin >> s;
map<char, int> m;
for (auto x : s) m[x]++;
for (int i = 0; i < 2; ++i) {
int c0 = 0;
for (auto& c : s) {
if (m[c] > n / 3 && m['0' + i] < n / 3) {
m[c]--;
c = '0' + i;
m[c]++;
} else if (c == '0' + i) {
c0++;
if (c0 > n / 3) {
m[c]--;
while (c < '3' && m[c] >= n / 3) c++;
m[c]++;
c0--;
}
}
}
}
cout << s;
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int T = 1;
while (T--) {
solve();
}
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
Fox Ciel and her friends are in a dancing room. There are n boys and m girls here, and they never danced before. There will be some songs, during each song, there must be exactly one boy and one girl are dancing. Besides, there is a special rule:
* either the boy in the dancing pair must dance for the first time (so, he didn't dance with anyone before);
* or the girl in the dancing pair must dance for the first time.
Help Fox Ciel to make a schedule that they can dance as many songs as possible.
Input
The first line contains two integers n and m (1 β€ n, m β€ 100) β the number of boys and girls in the dancing room.
Output
In the first line print k β the number of songs during which they can dance. Then in the following k lines, print the indexes of boys and girls dancing during songs chronologically. You can assume that the boys are indexed from 1 to n, and the girls are indexed from 1 to m.
Examples
Input
2 1
Output
2
1 1
2 1
Input
2 2
Output
3
1 1
1 2
2 2
Note
In test case 1, there are 2 boys and 1 girl. We can have 2 dances: the 1st boy and 1st girl (during the first song), the 2nd boy and 1st girl (during the second song).
And in test case 2, we have 2 boys with 2 girls, the answer is 3.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
cout << m + n - 1 << endl;
for (int i = 1; i <= m; ++i) cout << 1 << " " << i << endl;
for (int i = 2; i <= n; ++i) cout << i << " " << 1 << endl;
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
The Looksery company, consisting of n staff members, is planning another big party. Every employee has his phone number and the phone numbers of his friends in the phone book. Everyone who comes to the party, sends messages to his contacts about how cool it is. At the same time everyone is trying to spend as much time on the fun as possible, so they send messages to everyone without special thinking, moreover, each person even sends a message to himself or herself.
Igor and Max, Looksery developers, started a dispute on how many messages each person gets. Igor indicates n numbers, the i-th of which indicates how many messages, in his view, the i-th employee is going to take. If Igor guesses correctly at least one of these numbers, he wins, otherwise Max wins.
You support Max in this debate, so you need, given the contact lists of the employees, to determine whether there is a situation where Igor loses. Specifically, you need to determine which employees should come to the party, and which should not, so after all the visitors send messages to their contacts, each employee received a number of messages that is different from what Igor stated.
Input
The first line contains a single integer n (1 β€ n β€ 100) β the number of employees of company Looksery.
Next n lines contain the description of the contact lists of the employees. The i-th of these lines contains a string of length n, consisting of digits zero and one, specifying the contact list of the i-th employee. If the j-th character of the i-th string equals 1, then the j-th employee is in the i-th employee's contact list, otherwise he isn't. It is guaranteed that the i-th character of the i-th line is always equal to 1.
The last line contains n space-separated integers: a1, a2, ..., an (0 β€ ai β€ n), where ai represents the number of messages that the i-th employee should get according to Igor.
Output
In the first line print a single integer m β the number of employees who should come to the party so that Igor loses the dispute.
In the second line print m space-separated integers β the numbers of these employees in an arbitrary order.
If Igor wins the dispute in any case, print -1.
If there are multiple possible solutions, print any of them.
Examples
Input
3
101
010
001
0 1 2
Output
1
1
Input
1
1
1
Output
0
Input
4
1111
0101
1110
0001
1 0 1 0
Output
4
1 2 3 4
Note
In the first sample Igor supposes that the first employee will receive 0 messages. Since he isn't contained in any other contact list he must come to the party in order to receive one message from himself. If he is the only who come to the party then he will receive 1 message, the second employee will receive 0 messages and the third will also receive 1 message. Thereby Igor won't guess any number.
In the second sample if the single employee comes to the party he receives 1 message and Igor wins, so he shouldn't do it.
In the third sample the first employee will receive 2 messages, the second β 3, the third β 2, the fourth β 3.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int maxn = 1111111;
const int INF = 1 << 26;
const int logN = 18;
int n;
char g[111][111];
int a[111];
int cnt[111];
int vis[111];
void upd(int x) {
for (int(i) = 0; i < (int)(n); ++(i))
if (g[x][i] == '1') cnt[i]++;
}
int main(int argc, char const *argv[]) {
scanf("%d", &(n));
for (int(i) = 0; i < (int)(n); ++(i)) scanf("%s", (g[i]));
for (int(i) = 0; i < (int)(n); ++(i)) scanf("%d", &(a[i]));
queue<int> q;
for (int(i) = 0; i < (int)(n); ++(i))
if (a[i] == 0) {
q.push(i);
}
while (!q.empty()) {
int x = q.front();
q.pop();
if (vis[x]) continue;
vis[x] = 1;
upd(x);
for (int i = 0; i < n; ++i)
if (cnt[i] == a[i]) q.push(i);
}
for (int(i) = 0; i < (int)(n); ++(i))
if (cnt[i] == a[i]) {
puts("-1");
return 0;
}
vector<int> ans;
for (int(i) = 0; i < (int)(n); ++(i))
if (vis[i]) ans.push_back(i + 1);
printf("%d\n", (ans.size()));
for (int(i) = 0; i < (int)(ans.size()); ++(i))
printf("%d%c", ans[i], " \n"[i == ans.size() - 1]);
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
Btoh yuo adn yuor roomatme lhoate wianshg disehs, btu stlil sdmoeboy msut peorrfm tihs cohre dialy. Oen dya yuo decdie to idourtcne smoe syestm. Yuor rmmotaoe sstgegus teh fooniwllg dael. Yuo argee on tow arayrs of ientgres M adn R, nmebur upmicnog dyas (induiclng teh cunrret oen) wtih sicsescuve irnegets (teh ceurrnt dya is zreo), adn yuo wsah teh diehss on dya D if adn olny if terhe etsixs an iednx i scuh taht D mod M[i] = R[i], otwsehrie yuor rmootmae deos it. Yuo lkie teh cncepot, btu yuor rmotaome's cuinnng simle meaks yuo ssecupt sthnoemig, so yuo itennd to vefriy teh fnerisas of teh aemnrgeet.
Yuo aer geivn ayarrs M adn R. Cuaclatle teh pceanregte of dyas on wchih yuo edn up dnoig teh wisahng. Amsuse taht yuo hvae iiiftlneny mnay dyas aehad of yuo.
Input
The first line of input contains a single integer N (1 β€ N β€ 16).
The second and third lines of input contain N integers each, all between 0 and 16, inclusive, and represent arrays M and R, respectively. All M[i] are positive, for each i R[i] < M[i].
Output
Output a single real number. The answer is considered to be correct if its absolute or relative error does not exceed 10 - 4.
Examples
Input
1
2
0
Output
0.500000
Input
2
2 3
1 0
Output
0.666667
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 10;
int r[20], m[20];
int main() {
int n;
while (cin >> n) {
for (int i = 0; i < n; i++) cin >> m[i];
for (int i = 0; i < n; i++) cin >> r[i];
int sum = 0;
for (int i = 0; i < MAXN; i++) {
for (int j = 0; j < n; j++) {
if (i % m[j] == r[j]) {
sum++;
break;
}
}
}
printf("%.8lf\n", 1.0 * sum / (1.0 * MAXN));
}
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
In an attempt to escape the Mischievous Mess Makers' antics, Farmer John has abandoned his farm and is traveling to the other side of Bovinia. During the journey, he and his k cows have decided to stay at the luxurious Grand Moo-dapest Hotel. The hotel consists of n rooms located in a row, some of which are occupied.
Farmer John wants to book a set of k + 1 currently unoccupied rooms for him and his cows. He wants his cows to stay as safe as possible, so he wishes to minimize the maximum distance from his room to the room of his cow. The distance between rooms i and j is defined as |j - i|. Help Farmer John protect his cows by calculating this minimum possible distance.
Input
The first line of the input contains two integers n and k (1 β€ k < n β€ 100 000) β the number of rooms in the hotel and the number of cows travelling with Farmer John.
The second line contains a string of length n describing the rooms. The i-th character of the string will be '0' if the i-th room is free, and '1' if the i-th room is occupied. It is guaranteed that at least k + 1 characters of this string are '0', so there exists at least one possible choice of k + 1 rooms for Farmer John and his cows to stay in.
Output
Print the minimum possible distance between Farmer John's room and his farthest cow.
Examples
Input
7 2
0100100
Output
2
Input
5 1
01010
Output
2
Input
3 2
000
Output
1
Note
In the first sample, Farmer John can book room 3 for himself, and rooms 1 and 4 for his cows. The distance to the farthest cow is 2. Note that it is impossible to make this distance 1, as there is no block of three consecutive unoccupied rooms.
In the second sample, Farmer John can book room 1 for himself and room 3 for his single cow. The distance between him and his cow is 2.
In the third sample, Farmer John books all three available rooms, taking the middle room for himself so that both cows are next to him. His distance from the farthest cow is 1.
### Response
```cpp
/*
Nintai-ryoku ga ari, jikan ga kakaru purosesu o shinrai suru
~ ζ»η₯
*/
#include <bits/stdc++.h>
/*
#include<boost/multiprecision/cpp_int.hpp>
namespace mp=boost::multiprecision;
*/
using namespace std;
/*!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!shortcuts!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
#define ll long long int
// #define ll int
#define lo mp::cpp_int
#define pb push_back
#define pob pop_back
#define mk make_pair
#define endl "\n"
#define ce(x) cout << x <<"\n"
#define fill(s,v) memset(s,v,sizeof(s))
#define speed {ios_base::sync_with_stdio(false); cin.tie(0); }
#define deb(x) cout<<#x<<" "<<x<<endl;
#define ull unsigned long long int
#define in(a) ll a;cin>>a;
#define in2(a,b) in(a)in(b)
#define in3(a,b,c) in2(a,b)in(c)
#define in4(a,b,c,d) in2(a,b)in2(c,d)
#define in5(a,b,c,d,e) in4(a,b,c,d)in(e)
#define in6(a,b,c,d,e,f) in3(a,b,c)in3(d,e,f)
#define in7(a,b,c,d,e,f,g) in6(a,b,c,d,e,f)in(g)
#define in8(a,b,c,d,e,f,g,h) in7(a,b,c,d,e,f,g)in(h)
#define YES cout<<"YES"<<endl;
#define Yes cout<<"Yes"<<endl;
#define NO cout<<"NO"<<endl;
#define No cout<<"No"<<endl;
#define yes cout<<"yes"<<endl;
#define no cout<<"no"<<endl;
#define take(a,n) for(ll pp=0;pp<n;pp++) { cin>>a[pp]; }
#define take2(a,n) for(ll p=0;p<n;p++) { ll temp;cin>>temp;a.pb(temp); }
#define f(i,n) for(ll i=0;i<n;i++)
#define f1(i,a,n) for(ll i=a;i<n;i++)
#define show(x) for(auto t:x)cout<<t<<" ";
// #define show(a,n) for(ll p=0;p<n;p++) cout<<a[p]<<" ";
#define _ <<" "<<
#define nl cout<<endl;
#define sq(x) ((x)*(x))
#define call(v) v.begin(),v.end()
#define rall(v) v.rbegin(),v.rend()
#define ff first
#define ss second
#define ld long double
#define de2(x,y) cout<<#x<<" = "<<(x) <<' '<< #y<<" = "<<y<<endl;typedef pair<ll,ll> pii;
#define copy(b,a,n) for(ll i=0;i<n;i++) b[i]=a[i];
#define lelo(b) for(auto &i:b)cin>>i;
#define tc(tt) \
ll tt; \
cin>>tt; \
for(ll _tt=0;_tt<tt; _tt++)
/*!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!data-structures!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
typedef vector<vector<ll>> matrix ;
typedef pair<ll,ll> pii;
typedef vector<pii> vii;
typedef vector<ll> vi;
/*!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!helping-arrays!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
const ll dx[4] = {-1,0,1,0};
const ll dy[4] = {0,-1,0,1};
const ll dxx[] = {1,1,0,-1,-1,-1,0,1};
const ll dyy[] = {0,1,1,1,0,-1,-1,-1};
/*!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!constants!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
const ll mod=1000000007;
const ll mod2=1000000009;
#define pi 3.1415926535897932
const int N=(int)(1e6+10);
const int FULL_MASK=(1<<10)-1;
/*!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!Helping-Algos!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
//---------------Kadanes-algo-------------------//
ll maxSubArraySum(ll a[],ll size){
ll max_so_far=a[0];
ll curr_max=a[0];
for (ll i=1;i<size;i++) {
curr_max=max(a[i],curr_max+a[i]);
max_so_far=max(max_so_far,curr_max);
}
return max_so_far;
}
//---------------Fendwick-------------------//
int fendwick[N];
void update(int i,int add) {
while(i>0 && i<N){
fendwick[i]+=add;
i+=(i&(-i));
}
}
int sum(int i){
int s=0;
while(i>0){
s+=fendwick[i];
i=i-(i&(-i));
}
return s;
}
/*!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!helping-functions!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
ll gcd(ll a,ll b){if(!b)return a;return gcd(b,a%b);}
ll power_mod(ll x,ll y,ll p){ll res=1;x%=p;while(y>0){if(y&1)res=(res*x)%p;y=y>>1;x=(x*x)%p;}return res;}
ll modexpo(ll x,ll n,ll M){if(n==0)return 1;else if(n%2 == 0)return modexpo((x*x)%M,n/2,M);else return(x*modexpo((x*x)%M,(n-1)/2,M))%M;}
ll lcm(ll a, ll b){return (a*b)/gcd(a, b);}
ll sumofdigits(ll n){ll out=0;while(n){out+=(n%10);n/=10;}return out;}
bool isPrime(ll n){if (n <= 1)
return false; if (n <= 3) return true; if (n%2 == 0 || n%3 == 0) return false;
for (ll i=5; i*i<=n; i=i+6) if (n%i == 0 || n%(i+2) == 0) return false;return true;}
// ll power(ll a,ll b){if(b==0)return 1;if(b&1)return a*power(a,b-1);ll res=power(a,b/2);return res*res;}
ll bexpo(ll x,ll n){if(n==0)return 1;else if(n%2==0)return bexpo(x*x,n/2);else return x*bexpo(x*x,(n-1)/2);}
ll log(ll d){return log2(d);}
bool isPower(ll x, ll y){if(x==1) return (y==1); ll pow=1; while(pow<y) pow*=x; return(pow == y);}
bool isPerfectSquare(long double x){long double sr = sqrt(x);return ((sr - floor(sr)) == 0);}
bool compare(const pair<ll,ll> &a, const pair<ll,ll> &b) { return (a.second < b.second);}
ll isPalindrome(string s){ll l=0;ll h=s.size()-1;while(h>l){if(s[l++]!=s[h--])return 0;}return 1;}
ll setbits(ll n) { if(n==0)return 0; else return 1+setbits(n&(n-1)); }
ll modInverse(ll A,ll M){return modexpo(A,M-2,M);}
ll suma(ll *a,ll n){ll sum=0;for(ll i=0;i<n;i++)sum+=a[i];return sum;}
//------modular inverse by extended euclid-------//
// ll d, x, y;
// void extendedEuclid(ll A, ll B) {
// if(B==0){
// d=A;
// x=1;
// y=0;
// }
// else{
// extendedEuclid(B,A%B);
// ll temp=x;
// x=y;
// y=temp-(A/B)*y;
// }
// }
// ll modInverse2(ll A, ll M){
// extendedEuclid(A,M);
// return (x%M+M)%M;
// }
//---------------matrix exponentiation-------------------//
// matrix mul(matrix a,matrix b){
// matrix res(n+1,vector<ll>(n+1));
// f(i,n)f(j,n)f(k,n)res[i][j]=(res[i][j]%mod+((a[i][k]%mod)*(b[k][j]%mod))%mod)%mod;
// return res;
// }
// matrix pow(matrix A,ll p) {
// if(p==1) return A;
// matrix res=pow(A,p/2) ;
// res=mul(res,res);
// if(p&1) res=mul(res,A) ;
// return res;
// }
vector<ll> factorize(ll n) {
vector<ll> res;
for (ll i = 2; i * i <= n; ++i) {
while (n % i == 0) {
res.push_back(i);
n /= i;
}
}
if (n != 1) {
res.push_back(n);
}
return res;
}
vector<ll> divisors(ll n){
vector<ll> res;
for (ll i=1; i<=sqrt(n); i++){
if (n%i == 0){ if (n/i == i){ res.pb(i); } else{ res.pb(n/i); res.pb(i); } }
}
return res;
}
vector<ll> primeFactors(ll n){
if(n==1) return vector<ll>(1,1);
bool idx[1]={false};
vector<ll> res;
while (n%2 == 0){
if(!idx[1]){idx[1]=true;res.pb(2);}
n = n/2;
}
for (ll i=3;i*i<=n; i+=2){
bool once=false;
while (n%i==0){ if(!once){res.pb(i);once=true;} n=n/i; }
}
if (n > 2)res.pb(n);
return res;
}
//----check if a point is in range-----///
bool check(ll x,ll y,ll n,ll m){return(x>=0&&x<n&&y>=0&&y<m);}
//__builtin_ctz(x) --> get power of 2 !!!!
//---------------BFS-------------------//
vector<vector<ll>> ed;
void bfs(ll s, vector<ll> &d) {
d[s] = 0;
queue<ll> q;
q.push(s);
while (!q.empty()) {
ll v = q.front();
q.pop();
for (auto to : ed[v]) {
if (d[to] == 1e9) {
d[to] = d[v] + 1;
q.push(to);
}
}
}
}
//---------------DFS-------------------//
// void dfs(int u){
// vis[u]=1;
// // temp.push_back(u);
// for(int i=0;i<adj[u].size();i++){
// if(!vis[adj[u][i]])
// dfs(adj[u][i]);
// }
// }
// void dfs(ll u){
// if(vis[u]) return;
// deg += g[u].size();
// ver++;
// vis[u] = 1;
// for(auto v: g[u])dfs(v);
// }
/*!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!extra-data-structures!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
struct node{
ll a,b,c,d;
};
/*!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!logic!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
bool ch(ll mid,std::vector<ll> dp,string s,ll n,ll k){
f1(i,1,n){
if(s[i-1]=='0'){
ll left=dp[i-1]-dp[max((ll)0,i-1-mid)];
ll right=dp[min(n,i+mid)]-dp[i];
if(left+right>=k){
return true;
}
}
}
return false;
}
void solve(){
in2(n,k);
string s; cin>>s;
vi dp(n+2);
dp[0]=0;
for(ll i=1;i<=n;i++){
dp[i]=dp[i-1]+(s[i-1]=='0');
}
// show(dp);
ll l=0,r=n,ans=0;
while(l<=r){
ll mid=(l+r)>>1;
if(ch(mid,dp,s,n,k)){
// deb(mid);
ans=mid;
r=mid-1;
}
else{
l=mid+1;
}
}
ce(ans);
}
int main(){
// speed
// tc(tt){
solve();
// }
}
/*!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!test-cases!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
/*
*/
``` |
### Prompt
Please create a solution in Cpp to the following problem:
Little Chris is having a nightmare. Even in dreams all he thinks about is math.
Chris dreams about m binary strings of length n, indexed with numbers from 1 to m. The most horrifying part is that the bits of each string are ordered in either ascending or descending order. For example, Chris could be dreaming about the following 4 strings of length 5:
<image>
The Hamming distance H(a, b) between two strings a and b of length n is the number of positions at which the corresponding symbols are different.
Π‘hris thinks that each three strings with different indices constitute a single triple. Chris's delusion is that he will wake up only if he counts the number of such string triples a, b, c that the sum H(a, b) + H(b, c) + H(c, a) is maximal among all the string triples constructed from the dreamed strings.
Help Chris wake up from this nightmare!
Input
The first line of input contains two space-separated integers n and m (1 β€ n β€ 109; 3 β€ m β€ 105), the length and the number of strings. The next m lines contain the description of the strings. The i-th line contains two space-separated integers si and fi (0 β€ si β€ 1; 1 β€ fi β€ n), the description of the string with index i; that means that the first fi bits of the i-th string are equal to si, and the remaining n - fi bits are equal to 1 - si. There can be multiple equal strings in Chris's dream.
Output
Output a single integer, the number of such string triples among the given that the sum of the Hamming distances between the strings of the triple is maximal.
Examples
Input
5 4
0 3
0 5
1 4
1 5
Output
3
Input
10 4
1 5
0 5
0 5
1 5
Output
4
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x;
char c;
while ((c = getchar()) < '0' || c > '9')
;
for (x = c - '0'; (c = getchar()) >= '0' && c <= '9';) x = x * 10 + c - '0';
return x;
}
vector<int> v[2];
int mx;
long long s;
inline void rw(int x, long long y) {
x > mx ? mx = x, s = y : x < mx ? 0 : s += y;
}
int main() {
int n, m, i, x, a, b;
n = read();
m = read();
while (m--) x = read(), v[x].push_back(read());
for (x = 0; x < 2; ++x) sort(v[x].begin(), v[x].end());
for (x = 0; x < 2; ++x)
for (i = 0; i < v[x].size(); ++i) {
a = lower_bound(v[x ^ 1].begin(), v[x ^ 1].end(), v[x][i]) -
v[x ^ 1].begin();
b = upper_bound(v[x ^ 1].begin(), v[x ^ 1].end(), v[x][i]) -
v[x ^ 1].begin();
s += 1LL * a * (v[x ^ 1].size() - a) + 1LL * (b - a) * (b - a - 1) / 2 +
1LL * (b - a) * (v[x ^ 1].size() - b);
}
if (s) return 0 * printf("%I64d", s);
for (x = 0; x < 2; ++x)
if (v[x].size()) {
if (v[x][0] == v[x][v[x].size() - 1])
rw(0, 1LL * v[x].size() * (v[x].size() - 1) * (v[x].size() - 2) / 6);
else {
a = upper_bound(v[x].begin(), v[x].end(), v[x][0]) - v[x].begin();
b = lower_bound(v[x].begin(), v[x].end(), v[x][v[x].size() - 1]) -
v[x].begin();
rw(v[x][v[x].size() - 1] - v[x][0],
1LL * a * (a - 1) / 2 * (v[x].size() - b) +
1LL * a * (v[x].size() - b) * (v[x].size() - b - 1) / 2 +
1LL * a * (b - a) * (v[x].size() - b));
}
for (i = 0; i < v[x].size(); ++i) {
a = lower_bound(v[x ^ 1].begin(), v[x ^ 1].end(), v[x][i]) -
v[x ^ 1].begin();
if (a) {
b = lower_bound(v[x ^ 1].begin(), v[x ^ 1].end(), v[x ^ 1][a - 1]) -
v[x ^ 1].begin();
rw(n - v[x][i] + v[x ^ 1][a - 1],
1LL * (a - b) * (a - b - 1) / 2 + 1LL * (a - b) * b);
}
if (a < v[x ^ 1].size()) {
b = upper_bound(v[x ^ 1].begin(), v[x ^ 1].end(), v[x ^ 1][a]) -
v[x ^ 1].begin();
rw(n - v[x ^ 1][a] + v[x][i],
1LL * (b - a) * (b - a - 1) / 2 +
1LL * (b - a) * (v[x ^ 1].size() - b));
}
}
}
printf("%I64d", s);
}
``` |
### Prompt
Create a solution in CPP for the following problem:
You are given two segments [l_1; r_1] and [l_2; r_2] on the x-axis. It is guaranteed that l_1 < r_1 and l_2 < r_2. Segments may intersect, overlap or even coincide with each other.
<image> The example of two segments on the x-axis.
Your problem is to find two integers a and b such that l_1 β€ a β€ r_1, l_2 β€ b β€ r_2 and a β b. In other words, you have to choose two distinct integer points in such a way that the first point belongs to the segment [l_1; r_1] and the second one belongs to the segment [l_2; r_2].
It is guaranteed that the answer exists. If there are multiple answers, you can print any of them.
You have to answer q independent queries.
Input
The first line of the input contains one integer q (1 β€ q β€ 500) β the number of queries.
Each of the next q lines contains four integers l_{1_i}, r_{1_i}, l_{2_i} and r_{2_i} (1 β€ l_{1_i}, r_{1_i}, l_{2_i}, r_{2_i} β€ 10^9, l_{1_i} < r_{1_i}, l_{2_i} < r_{2_i}) β the ends of the segments in the i-th query.
Output
Print 2q integers. For the i-th query print two integers a_i and b_i β such numbers that l_{1_i} β€ a_i β€ r_{1_i}, l_{2_i} β€ b_i β€ r_{2_i} and a_i β b_i. Queries are numbered in order of the input.
It is guaranteed that the answer exists. If there are multiple answers, you can print any.
Example
Input
5
1 2 1 2
2 6 3 4
2 4 1 3
1 2 1 3
1 4 5 8
Output
2 1
3 4
3 2
1 2
3 7
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, r1, r2, l1, l2;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> l1 >> r1 >> l2 >> r2;
if (l1 == l2)
cout << l1 << " " << r2;
else
cout << l1 << " " << l2;
cout << endl;
}
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
Polycarp wants to cook a soup. To do it, he needs to buy exactly n liters of water.
There are only two types of water bottles in the nearby shop β 1-liter bottles and 2-liter bottles. There are infinitely many bottles of these two types in the shop.
The bottle of the first type costs a burles and the bottle of the second type costs b burles correspondingly.
Polycarp wants to spend as few money as possible. Your task is to find the minimum amount of money (in burles) Polycarp needs to buy exactly n liters of water in the nearby shop if the bottle of the first type costs a burles and the bottle of the second type costs b burles.
You also have to answer q independent queries.
Input
The first line of the input contains one integer q (1 β€ q β€ 500) β the number of queries.
The next q lines contain queries. The i-th query is given as three space-separated integers n_i, a_i and b_i (1 β€ n_i β€ 10^{12}, 1 β€ a_i, b_i β€ 1000) β how many liters Polycarp needs in the i-th query, the cost (in burles) of the bottle of the first type in the i-th query and the cost (in burles) of the bottle of the second type in the i-th query, respectively.
Output
Print q integers. The i-th integer should be equal to the minimum amount of money (in burles) Polycarp needs to buy exactly n_i liters of water in the nearby shop if the bottle of the first type costs a_i burles and the bottle of the second type costs b_i burles.
Example
Input
4
10 1 3
7 3 2
1 1000 1
1000000000000 42 88
Output
10
9
1000
42000000000000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
while (q--) {
long long int n, a, b;
cin >> n >> a >> b;
long long int answer;
if (b > 2 * a) {
answer = n * a;
} else {
answer = (n / 2) * b + (n % 2) * a;
}
cout << answer << endl;
}
return 0;
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
You might have remembered Theatre square from the [problem 1A](https://codeforces.com/problemset/problem/1/A). Now it's finally getting repaved.
The square still has a rectangular shape of n Γ m meters. However, the picture is about to get more complicated now. Let a_{i,j} be the j-th square in the i-th row of the pavement.
You are given the picture of the squares:
* if a_{i,j} = "*", then the j-th square in the i-th row should be black;
* if a_{i,j} = ".", then the j-th square in the i-th row should be white.
The black squares are paved already. You have to pave the white squares. There are two options for pavement tiles:
* 1 Γ 1 tiles β each tile costs x burles and covers exactly 1 square;
* 1 Γ 2 tiles β each tile costs y burles and covers exactly 2 adjacent squares of the same row. Note that you are not allowed to rotate these tiles or cut them into 1 Γ 1 tiles.
You should cover all the white squares, no two tiles should overlap and no black squares should be covered by tiles.
What is the smallest total price of the tiles needed to cover all the white squares?
Input
The first line contains a single integer t (1 β€ t β€ 500) β the number of testcases. Then the description of t testcases follow.
The first line of each testcase contains four integers n, m, x and y (1 β€ n β€ 100; 1 β€ m β€ 1000; 1 β€ x, y β€ 1000) β the size of the Theatre square, the price of the 1 Γ 1 tile and the price of the 1 Γ 2 tile.
Each of the next n lines contains m characters. The j-th character in the i-th line is a_{i,j}. If a_{i,j} = "*", then the j-th square in the i-th row should be black, and if a_{i,j} = ".", then the j-th square in the i-th row should be white.
It's guaranteed that the sum of n Γ m over all testcases doesn't exceed 10^5.
Output
For each testcase print a single integer β the smallest total price of the tiles needed to cover all the white squares in burles.
Example
Input
4
1 1 10 1
.
1 2 10 1
..
2 1 10 1
.
.
3 3 3 7
..*
*..
.*.
Output
10
1
20
18
Note
In the first testcase you are required to use a single 1 Γ 1 tile, even though 1 Γ 2 tile is cheaper. So the total price is 10 burles.
In the second testcase you can either use two 1 Γ 1 tiles and spend 20 burles or use a single 1 Γ 2 tile and spend 1 burle. The second option is cheaper, thus the answer is 1.
The third testcase shows that you can't rotate 1 Γ 2 tiles. You still have to use two 1 Γ 1 tiles for the total price of 20.
In the fourth testcase the cheapest way is to use 1 Γ 1 tiles everywhere. The total cost is 6 β
3 = 18.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t;
cin >> t;
while (t--) {
long long int n, m, x, y;
cin >> n >> m >> x >> y;
char arr[1001][1001];
for (long long int i = 0; i < n; i++) {
string s;
cin >> s;
for (long long int j = 0; j < m; j++) arr[i][j] = s[j];
}
if (2 * x < y) y = 2 * x;
long long int ans = 0;
for (long long int i = 0; i < n; i++) {
for (long long int j = 0; j < m; j++) {
if (arr[i][j] == '.') {
if (j + 1 < m && arr[i][j + 1] == '.') {
arr[i][j] = '*';
arr[i][j + 1] = '*';
ans += y;
} else {
arr[i][j] = '*';
ans += x;
}
}
}
}
cout << ans << endl;
}
}
``` |
### Prompt
Generate a CPP solution to the following problem:
Young boy Artem tries to paint a picture, and he asks his mother Medina to help him. Medina is very busy, that's why she asked for your help.
Artem wants to paint an n Γ m board. Each cell of the board should be colored in white or black.
Lets B be the number of black cells that have at least one white neighbor adjacent by the side. Let W be the number of white cells that have at least one black neighbor adjacent by the side. A coloring is called good if B = W + 1.
The first coloring shown below has B=5 and W=4 (all cells have at least one neighbor with the opposite color). However, the second coloring is not good as it has B=4, W=4 (only the bottom right cell doesn't have a neighbor with the opposite color).
<image>
Please, help Medina to find any good coloring. It's guaranteed that under given constraints the solution always exists. If there are several solutions, output any of them.
Input
Each test contains multiple test cases.
The first line contains the number of test cases t (1 β€ t β€ 20). Each of the next t lines contains two integers n, m (2 β€ n,m β€ 100) β the number of rows and the number of columns in the grid.
Output
For each test case print n lines, each of length m, where i-th line is the i-th row of your colored matrix (cell labeled with 'B' means that the cell is black, and 'W' means white). Do not use quotes.
It's guaranteed that under given constraints the solution always exists.
Example
Input
2
3 2
3 3
Output
BW
WB
BB
BWB
BWW
BWB
Note
In the first testcase, B=3, W=2.
In the second testcase, B=5, W=4. You can see the coloring in the statement.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int r, c;
int main() {
int n;
scanf("%d", &n);
while (n--) {
scanf("%d %d", &r, &c);
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++)
if (i == r - 1 && j == c - 1)
printf("W");
else
printf("B");
printf("\n");
}
}
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
You have an integer variable x. Initially, x=0.
Some person gave you a string S of length N, and using the string you performed the following operation N times. In the i-th operation, you incremented the value of x by 1 if S_i=`I`, and decremented the value of x by 1 if S_i=`D`.
Find the maximum value taken by x during the operations (including before the first operation, and after the last operation).
Constraints
* 1β€Nβ€100
* |S|=N
* No characters except `I` and `D` occur in S.
Input
The input is given from Standard Input in the following format:
N
S
Output
Print the maximum value taken by x during the operations.
Examples
Input
5
IIDID
Output
2
Input
7
DDIDDII
Output
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(){
int n,res=0,ans=0;
string s;
cin>>n>>s;
for(int i=0; i<n; i++) {
if(s[i]=='I') res++;
else res--;
ans = max(res,ans);
}
cout<<max(res,ans);
}
``` |
### Prompt
Create a solution in cpp for the following problem:
BCPC stands for Byteforces Collegiate Programming Contest, and is the most famous competition in Byteforces.
BCPC is a team competition. Each team is composed by a coach and three contestants. Blenda is the coach of the Bit State University(BSU), and she is very strict selecting the members of her team.
<image>
In BSU there are n students numbered from 1 to n. Since all BSU students are infinitely smart, the only important parameters for Blenda are their reading and writing speed. After a careful measuring, Blenda have found that the i-th student have a reading speed equal to ri (words per minute), and a writing speed of wi (symbols per minute). Since BSU students are very smart, the measured speeds are sometimes very big and Blenda have decided to subtract some constant value c from all the values of reading speed and some value d from all the values of writing speed. Therefore she considers ri' = ri - c and wi' = wi - d.
The student i is said to overwhelm the student j if and only if ri'Β·wj' > rj'Β·wi'. Blenda doesnβt like fights in teams, so she thinks that a team consisting of three distinct students i, j and k is good if i overwhelms j, j overwhelms k, and k overwhelms i. Yes, the relation of overwhelming is not transitive as it often happens in real life.
Since Blenda is busy preparing a training camp in Codeforces, you are given a task to calculate the number of different good teams in BSU. Two teams are considered to be different if there is at least one student that is present in one team but is not present in the other. In other words, two teams are different if the sets of students that form these teams are different.
Input
In the first line of the input three integers n, c and d (3 β€ n β€ 345678, 1 β€ c, d β€ 109) are written. They denote the number of students Blenda can use to form teams, the value subtracted from all reading speeds and the value subtracted from all writing speeds respectively.
Each of the next n lines contains two integers ri and wi (0 < ri, wi β€ 109, |ri - c| + |wi - d| > 0). There are no two students, such that both their reading and writing speeds coincide, i.e. for every i β j condition |ri - rj| + |wi - wj| > 0 holds.
Output
Print the number of different teams in BSU, that are good according to Blenda's definition.
Examples
Input
5 2 2
1 1
4 1
2 3
3 2
3 4
Output
4
Input
7 6 6
3 2
1 7
5 7
3 7
6 4
8 9
8 5
Output
11
Note
In the first sample the following teams are good: (i = 1, j = 2, k = 3), (i = 2, j = 5, k = 1), (i = 1, j = 4, k = 3), (i = 5, j = 1, k = 4).
Note, that for example the team (i = 3, j = 1, k = 2) is also good, but is considered to be the same as the team (i = 1, j = 2, k = 3).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <typename TH>
void _dbg(const char* sdbg, TH h) {
cerr << sdbg << "=" << h << "\n";
}
template <typename TH, typename... TA>
void _dbg(const char* sdbg, TH h, TA... t) {
while (*sdbg != ',') cerr << *sdbg++;
cerr << "=" << h << ",";
_dbg(sdbg + 1, t...);
}
const int maxn = 4e5 + 5;
const long double pi = acos((long double)-1);
const long double esp = 1e-18;
pair<int, int> a[maxn];
int n;
long double v[maxn * 2];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
if (fopen("TEST"
".INP",
"r"))
freopen(
"TEST"
".INP",
"r", stdin),
freopen(
"TEST"
".OUT",
"w", stdout);
cin >> n;
cin >> a[n].first >> a[n].second;
for (int i = 0; i < n; ++i) {
cin >> a[i].first >> a[i].second;
a[i].first -= a[n].first;
a[i].second -= a[n].second;
long double now = atan2((long double)a[i].second, (long double)a[i].first);
(now);
v[i] = now;
}
long long res = 1ll * n * (n - 1) * (n - 2) / 6;
sort(v, v + n);
for (int i = 0; i < n; ++i) v[i + n] = v[i] + 2 * pi;
int j = 0, k = 0;
v[2 * n] = 1000;
for (int i = 0; i < n; ++i) {
(v[i]);
while (v[j] < v[i] + pi - esp) ++j;
while (v[k] < v[i] + pi + esp) ++k;
(i, j, k);
((long long)(k - j) * (k - j - 1) / 2,
(long long)(k - i - 1) * (k - i - 2) / 2);
res += (long long)(k - j) * (k - j - 1) / 2;
res -= (long long)(k - i - 2) * (k - i - 1) / 2;
}
cout << res;
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
The annual college sports-ball tournament is approaching, which for trademark reasons we'll refer to as Third Month Insanity. There are a total of 2N teams participating in the tournament, numbered from 1 to 2N. The tournament lasts N rounds, with each round eliminating half the teams. The first round consists of 2N - 1 games, numbered starting from 1. In game i, team 2Β·i - 1 will play against team 2Β·i. The loser is eliminated and the winner advances to the next round (there are no ties). Each subsequent round has half as many games as the previous round, and in game i the winner of the previous round's game 2Β·i - 1 will play against the winner of the previous round's game 2Β·i.
Every year the office has a pool to see who can create the best bracket. A bracket is a set of winner predictions for every game. For games in the first round you may predict either team to win, but for games in later rounds the winner you predict must also be predicted as a winner in the previous round. Note that the bracket is fully constructed before any games are actually played. Correct predictions in the first round are worth 1 point, and correct predictions in each subsequent round are worth twice as many points as the previous, so correct predictions in the final game are worth 2N - 1 points.
For every pair of teams in the league, you have estimated the probability of each team winning if they play against each other. Now you want to construct a bracket with the maximum possible expected score.
Input
Input will begin with a line containing N (2 β€ N β€ 6).
2N lines follow, each with 2N integers. The j-th column of the i-th row indicates the percentage chance that team i will defeat team j, unless i = j, in which case the value will be 0. It is guaranteed that the i-th column of the j-th row plus the j-th column of the i-th row will add to exactly 100.
Output
Print the maximum possible expected score over all possible brackets. Your answer must be correct to within an absolute or relative error of 10 - 9.
Formally, let your answer be a, and the jury's answer be b. Your answer will be considered correct, if <image>.
Examples
Input
2
0 40 100 100
60 0 40 40
0 60 0 45
0 60 55 0
Output
1.75
Input
3
0 0 100 0 100 0 0 0
100 0 100 0 0 0 100 100
0 0 0 100 100 0 0 0
100 100 0 0 0 0 100 100
0 100 0 100 0 0 100 0
100 100 100 100 100 0 0 0
100 0 100 0 0 100 0 0
100 0 100 0 100 100 100 0
Output
12
Input
2
0 21 41 26
79 0 97 33
59 3 0 91
74 67 9 0
Output
3.141592
Note
In the first example, you should predict teams 1 and 4 to win in round 1, and team 1 to win in round 2. Recall that the winner you predict in round 2 must also be predicted as a winner in round 1.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<vector<long double>> expected_score;
vector<vector<long double>> prob;
vector<vector<long long>> v;
long long N;
void solve() {
cin >> N;
v.resize((1 << N), vector<long long>((1 << N)));
for (long long i = 0; i < 1 << N; i++) {
for (long long j = 0; j < 1 << N; j++) cin >> v[i][j];
}
expected_score.resize(N + 1, vector<long double>((1 << N), 0));
prob.resize(N + 1, vector<long double>((1 << N), 0));
long double ans = 0;
for (long long h = 0; h <= N; h++) {
for (long long num = 0; num < (1 << N); num++) {
if (h == 0)
prob[h][num] = 1;
else {
expected_score[h][num] = expected_score[h - 1][num];
long double toadd = 0;
long double win_prob = 0;
for (long long def = 0; def < (1 << N); def++) {
if ((num >> h) == (def >> h) &&
(num & (1 << (h - 1))) ^ (def & (1 << (h - 1)))) {
toadd = max(toadd, expected_score[h - 1][def]);
prob[h][num] +=
prob[h - 1][num] * prob[h - 1][def] * (v[num][def]) / 100.0l;
win_prob +=
prob[h - 1][num] * prob[h - 1][def] * v[num][def] / 100.0l;
}
}
expected_score[h][num] += toadd + win_prob * (1 << h);
}
if (h == N) {
ans = max(ans, expected_score[h][num]);
}
}
}
cout << fixed << setprecision(10) << ans / 2.0l << '\n';
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) {
solve();
}
return 0;
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
Vanya got an important task β he should enumerate books in the library and label each book with its number. Each of the n books should be assigned with a number from 1 to n. Naturally, distinct books should be assigned distinct numbers.
Vanya wants to know how many digits he will have to write down as he labels the books.
Input
The first line contains integer n (1 β€ n β€ 109) β the number of books in the library.
Output
Print the number of digits needed to number all the books.
Examples
Input
13
Output
17
Input
4
Output
4
Note
Note to the first test. The books get numbers 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, which totals to 17 digits.
Note to the second sample. The books get numbers 1, 2, 3, 4, which totals to 4 digits.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
vector<long long> Vec;
if (n < 10)
cout << n << endl;
else {
long long ts3a = 9, sum = 0;
while (true) {
if (n > sum) Vec.push_back(ts3a);
sum += ts3a;
ts3a *= 10;
if (sum + ts3a > n) break;
}
Vec.push_back(n - sum);
long long out = 0;
for (int i = 0; i < Vec.size(); i++) {
out += (i + 1) * Vec[i];
}
cout << out << endl;
}
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
Translator's note: in Russia's most widespread grading system, there are four grades: 5, 4, 3, 2, the higher the better, roughly corresponding to A, B, C and F respectively in American grading system.
The term is coming to an end and students start thinking about their grades. Today, a professor told his students that the grades for his course would be given out automatically β he would calculate the simple average (arithmetic mean) of all grades given out for lab works this term and round to the nearest integer. The rounding would be done in favour of the student β 4.5 would be rounded up to 5 (as in example 3), but 4.4 would be rounded down to 4.
This does not bode well for Vasya who didn't think those lab works would influence anything, so he may receive a grade worse than 5 (maybe even the dreaded 2). However, the professor allowed him to redo some of his works of Vasya's choosing to increase his average grade. Vasya wants to redo as as few lab works as possible in order to get 5 for the course. Of course, Vasya will get 5 for the lab works he chooses to redo.
Help Vasya β calculate the minimum amount of lab works Vasya has to redo.
Input
The first line contains a single integer n β the number of Vasya's grades (1 β€ n β€ 100).
The second line contains n integers from 2 to 5 β Vasya's grades for his lab works.
Output
Output a single integer β the minimum amount of lab works that Vasya has to redo. It can be shown that Vasya can always redo enough lab works to get a 5.
Examples
Input
3
4 4 4
Output
2
Input
4
5 4 5 5
Output
0
Input
4
5 3 3 5
Output
1
Note
In the first sample, it is enough to redo two lab works to make two 4s into 5s.
In the second sample, Vasya's average is already 4.75 so he doesn't have to redo anything to get a 5.
In the second sample Vasya has to redo one lab work to get rid of one of the 3s, that will make the average exactly 4.5 so the final grade would be 5.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 1;
map<long long, long long> mp, pm;
deque<long long> v, vc, ve, vv;
deque<char> p, pe;
deque<string> ts, ss, st;
deque<double> sd, ds;
long long a, b, c, d, e, f, cnt, ans, r, n, l, z;
long double q, t, cnt1, cnt2;
string g, h, w, o, m, s;
char y, u;
bool re, rt;
vector<pair<long long, long long> > pr, rp, pp;
map<pair<long long, long long>, long long> aw, wa;
int main() {
cin.tie(NULL);
cout.tie(NULL);
ios_base::sync_with_stdio(0);
cin >> a;
for (long long i = 0; i < a; i++) {
cin >> b;
v.push_back(b);
}
sort(v.begin(), v.end());
for (long long i = 0; i < v.size(); i++) {
cnt1 = 0;
for (long long j = 0; j < v.size(); j++) cnt1 += v[j];
cnt1 = round(cnt1 / a);
if (cnt1 == 5) {
cout << cnt;
return 0;
}
v[i] = 5;
cnt++;
}
cout << a;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
A tree is a connected undirected graph consisting of n vertices and n - 1 edges. Vertices are numbered 1 through n.
Limak is a little polar bear. He once had a tree with n vertices but he lost it. He still remembers something about the lost tree though.
You are given m pairs of vertices (a1, b1), (a2, b2), ..., (am, bm). Limak remembers that for each i there was no edge between ai and bi. He also remembers that vertex 1 was incident to exactly k edges (its degree was equal to k).
Is it possible that Limak remembers everything correctly? Check whether there exists a tree satisfying the given conditions.
Input
The first line of the input contains three integers n, m and k (<image>) β the number of vertices in Limak's tree, the number of forbidden pairs of vertices, and the degree of vertex 1, respectively.
The i-th of next m lines contains two distinct integers ai and bi (1 β€ ai, bi β€ n, ai β bi) β the i-th pair that is forbidden. It's guaranteed that each pair of vertices will appear at most once in the input.
Output
Print "possible" (without quotes) if there exists at least one tree satisfying the given conditions. Otherwise, print "impossible" (without quotes).
Examples
Input
5 4 2
1 2
2 3
4 2
4 1
Output
possible
Input
6 5 3
1 2
1 3
1 4
1 5
1 6
Output
impossible
Note
In the first sample, there are n = 5 vertices. The degree of vertex 1 should be k = 2. All conditions are satisfied for a tree with edges 1 - 5, 5 - 2, 1 - 3 and 3 - 4.
In the second sample, Limak remembers that none of the following edges existed: 1 - 2, 1 - 3, 1 - 4, 1 - 5 and 1 - 6. Hence, vertex 1 couldn't be connected to any other vertex and it implies that there is no suitable tree.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long int const inf = 1e18;
long long int const maxn = 1e6 + 5;
long long int const mod = 1e9 + 7;
set<int> unvisited;
vector<pair<int, int>> v;
int cur = 0;
pair<int, int> fx(int x, int y) { return make_pair(min(x, y), max(x, y)); }
void dfs(int i) {
for (auto it = unvisited.begin(); it != unvisited.end();) {
if (!binary_search(v.begin(), v.end(), fx(i, *it))) {
int val = *it;
unvisited.erase(it);
dfs(val);
it = unvisited.upper_bound(val);
} else
it++;
}
}
void call_dfs() {
while (!unvisited.empty()) {
int v = *unvisited.begin();
unvisited.erase(unvisited.begin());
dfs(v);
cur++;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m, k, deg = 0;
cin >> n >> m >> k;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
if (x == 1 || y == 1) deg++;
v.push_back(fx(x, y));
}
sort(v.begin(), v.end());
for (int i = 1; i <= n; i++) unvisited.insert(i);
call_dfs();
if (cur != 1) {
cout << "impossible"
<< "\n";
;
return 0;
}
cur = 0;
for (int i = 2; i <= n; i++) unvisited.insert(i);
call_dfs();
if (cur <= k && (n - 1 - deg) >= k) {
cout << "possible"
<< "\n";
;
} else
cout << "impossible"
<< "\n";
;
return 0;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
Daniel has a string s, consisting of lowercase English letters and period signs (characters '.'). Let's define the operation of replacement as the following sequence of steps: find a substring ".." (two consecutive periods) in string s, of all occurrences of the substring let's choose the first one, and replace this substring with string ".". In other words, during the replacement operation, the first two consecutive periods are replaced by one. If string s contains no two consecutive periods, then nothing happens.
Let's define f(s) as the minimum number of operations of replacement to perform, so that the string does not have any two consecutive periods left.
You need to process m queries, the i-th results in that the character at position xi (1 β€ xi β€ n) of string s is assigned value ci. After each operation you have to calculate and output the value of f(s).
Help Daniel to process all queries.
Input
The first line contains two integers n and m (1 β€ n, m β€ 300 000) the length of the string and the number of queries.
The second line contains string s, consisting of n lowercase English letters and period signs.
The following m lines contain the descriptions of queries. The i-th line contains integer xi and ci (1 β€ xi β€ n, ci β a lowercas English letter or a period sign), describing the query of assigning symbol ci to position xi.
Output
Print m numbers, one per line, the i-th of these numbers must be equal to the value of f(s) after performing the i-th assignment.
Examples
Input
10 3
.b..bz....
1 h
3 c
9 f
Output
4
3
1
Input
4 4
.cc.
2 .
3 .
2 a
1 a
Output
1
3
1
1
Note
Note to the first sample test (replaced periods are enclosed in square brackets).
The original string is ".b..bz....".
* after the first query f(hb..bz....) = 4 ("hb[..]bz...." β "hb.bz[..].." β "hb.bz[..]." β "hb.bz[..]" β "hb.bz.")
* after the second query f(hbΡ.bz....) = 3 ("hbΡ.bz[..].." β "hbΡ.bz[..]." β "hbΡ.bz[..]" β "hbΡ.bz.")
* after the third query f(hbΡ.bz..f.) = 1 ("hbΡ.bz[..]f." β "hbΡ.bz.f.")
Note to the second sample test.
The original string is ".cc.".
* after the first query: f(..c.) = 1 ("[..]c." β ".c.")
* after the second query: f(....) = 3 ("[..].." β "[..]." β "[..]" β ".")
* after the third query: f(.a..) = 1 (".a[..]" β ".a.")
* after the fourth query: f(aa..) = 1 ("aa[..]" β "aa.")
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, ans = 0;
cin >> n >> m;
char str[n + 1];
str[0] = 'a', str[n + 1] = 'a';
for (int i = 1; i <= n; i++) cin >> str[i];
for (long long i = 1; i < n; i++)
if (str[i] == '.' && str[i + 1] == '.') ans++;
while (m--) {
int x;
char ch;
scanf("%d %c", &x, &ch);
if (ch == '.' && str[x] != '.') {
str[x] = '.';
if (str[x - 1] == '.') ans++;
if (str[x + 1] == '.') ans++;
}
if (ch != '.' && str[x] == '.') {
str[x] = ch;
if (str[x - 1] == '.') ans--;
if (str[x + 1] == '.') ans--;
}
printf("%d\n", ans);
}
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
There are N panels arranged in a row in Takahashi's house, numbered 1 through N. The i-th panel has a number A_i written on it. Takahashi is playing by throwing balls at these panels.
Takahashi threw a ball K times. Let the panel hit by a boll in the i-th throw be panel p_i. He set the score for the i-th throw as i \times A_{p_i}.
He was about to calculate the total score for his throws, when he realized that he forgot the panels hit by balls, p_1,p_2,...,p_K. The only fact he remembers is that for every i (1 β¦ i β¦ K-1), 1 β¦ p_{i+1}-p_i β¦ M holds. Based on this fact, find the maximum possible total score for his throws.
Constraints
* 1 β¦ M β¦ N β¦ 100,000
* 1 β¦ K β¦ min(300,N)
* 1 β¦ A_i β¦ 10^{9}
Input
The input is given from Standard Input in the following format:
N M K
A_1 A_2 β¦ A_N
Output
Print the maximum possible total score for Takahashi's throws.
Examples
Input
5 2 3
10 2 8 10 2
Output
56
Input
5 5 2
5 2 10 5 9
Output
28
Input
10 3 5
3 7 2 6 9 4 8 5 1 1000000000
Output
5000000078
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long INF=1000000000000000000ll;
void slidemin(int n,int m,long long *A,long long *B)
{
deque<int> Q;
for(int i=0;i<n;i++){
B[i]=(Q.empty()?INF:A[Q.front()]);
while(!Q.empty()&&A[Q.back()]>=A[i]){
Q.pop_back();
}
Q.push_back(i);
if(i>=m&&Q.front()==i-m){
Q.pop_front();
}
}
}
int main()
{
int n,m,k;
scanf("%d%d%d",&n,&m,&k);
static long long a[100000];
for(int i=0;i<n;i++){
scanf("%d",a+i);
}
static long long X[2][100000];
bool b=0;
for(int j=0;j<n;j++){
X[b][j]=-a[j];
}
for(int i=2;i<=k;i++){
slidemin(n,m,X[b],X[!b]);
for(int j=0;j<n;j++){
X[!b][j]-=i*a[j];
//printf("%d %d %lld\n",i,j,X[!b][j]);
}
b=!b;
}
long long ans=-INF;
for(int i=0;i<n;i++){
ans=max(ans,-X[b][i]);
}
printf("%lld\n",ans);
return 0;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
We have a sandglass that runs for X seconds. The sand drops from the upper bulb at a rate of 1 gram per second. That is, the upper bulb initially contains X grams of sand.
How many grams of sand will the upper bulb contains after t seconds?
Constraints
* 1β€Xβ€10^9
* 1β€tβ€10^9
* X and t are integers.
Input
The input is given from Standard Input in the following format:
X t
Output
Print the number of sand in the upper bulb after t second.
Examples
Input
100 17
Output
83
Input
48 58
Output
0
Input
1000000000 1000000000
Output
0
### Response
```cpp
#include<iostream>
using namespace std;
int main()
{
int n,m;
cin>>n>>m;
if(n-m>0) cout<<n-m;
else cout<<0;
return 0;
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
We have a sequence of N \times K integers: X=(X_0,X_1,\cdots,X_{N \times K-1}). Its elements are represented by another sequence of N integers: A=(A_0,A_1,\cdots,A_{N-1}). For each pair i, j (0 \leq i \leq K-1,\ 0 \leq j \leq N-1), X_{i \times N + j}=A_j holds.
Snuke has an integer sequence s, which is initially empty. For each i=0,1,2,\cdots,N \times K-1, in this order, he will perform the following operation:
* If s does not contain X_i: add X_i to the end of s.
* If s does contain X_i: repeatedly delete the element at the end of s until s no longer contains X_i. Note that, in this case, we do not add X_i to the end of s.
Find the elements of s after Snuke finished the operations.
Constraints
* 1 \leq N \leq 2 \times 10^5
* 1 \leq K \leq 10^{12}
* 1 \leq A_i \leq 2 \times 10^5
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N K
A_0 A_1 \cdots A_{N-1}
Output
Print the elements of s after Snuke finished the operations, in order from beginning to end, with spaces in between.
Examples
Input
3 2
1 2 3
Output
2 3
Input
5 10
1 2 3 2 3
Output
3
Input
6 1000000000000
1 1 2 2 3 3
Output
Input
11 97
3 1 4 1 5 9 2 6 5 3 5
Output
9 2 6
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using PII = pair<int, int>;
#define F first
#define S second
constexpr int maxn = 2e5 * 2 + 10;
int64_t k;
int n, a[maxn], f[maxn], g[maxn];
int main() {
scanf("%d%lld", &n, &k);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
a[i + n] = a[i];
}
unordered_map<int, int> m;
for (int i = n * 2; i >= 1; --i) {
if (m.count(a[i])) {
f[i] = m[a[i]] + 1;
} else {
f[i] = i;
}
m[a[i]] = i;
}
f[n * 2 + 1] = n * 2 + 1;
for (int i = n * 2 + 1; i >= 1; --i) {
g[i] = i == f[i] ? f[i] : g[f[i]];
}
int s = n + 1;
m.clear();
int cnt = 0;
while (k-- > 0) {
s = g[s] - n;
cnt++;
if (m.count(s)) {
int len = cnt - m[s];
k %= len;
}
m[s] = cnt;
}
unordered_set<int> vis;
vector<int> st;
for (int i = s; i <= n; ++i) {
if (vis.count(a[i])) {
while (st.back() != a[i]) {
vis.erase(st.back());
st.pop_back();
}
vis.erase(st.back());
st.pop_back();
} else{
vis.insert(a[i]);
st.push_back(a[i]);
}
}
for (size_t i = 0; i < st.size(); ++i)
printf("%d%c", st[i], " \n"[i + 1 == st.size()]);
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
Takahashi and Aoki are going to together construct a sequence of integers.
First, Takahashi will provide a sequence of integers a, satisfying all of the following conditions:
* The length of a is N.
* Each element in a is an integer between 1 and K, inclusive.
* a is a palindrome, that is, reversing the order of elements in a will result in the same sequence as the original.
Then, Aoki will perform the following operation an arbitrary number of times:
* Move the first element in a to the end of a.
How many sequences a can be obtained after this procedure, modulo 10^9+7?
Constraints
* 1β€Nβ€10^9
* 1β€Kβ€10^9
Input
The input is given from Standard Input in the following format:
N K
Output
Print the number of the sequences a that can be obtained after the procedure, modulo 10^9+7.
Examples
Input
4 2
Output
6
Input
1 10
Output
10
Input
6 3
Output
75
Input
1000000000 1000000000
Output
875699961
### Response
```cpp
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <cmath>
using namespace std;
const int MAXN = 50000 + 100;
const int MOD = 1000000000 + 7;
int n, m, k;
int d[MAXN], f[MAXN];
int fpow(int x, int p)
{
int ret = 1;
for(; p; p >>= 1, x = (long long)x * x % MOD)
if(p & 1)
ret = (long long)ret * x % MOD;
return ret;
}
int main()
{
ios::sync_with_stdio(false);
// freopen("1.in", "r", stdin);
// freopen("1.out", "w", stdout);
cin >> n >> k;
m = 0;
for(int i = 1; i * i <= n; i++)
if(n % i == 0)
{
d[++m] = i;
if(i != n / i)
d[++m] = n / i;
}
sort(d + 1, d + m + 1);
for(int i = 1; i <= m; i++)
{
f[i] = fpow(k, (d[i] + 1) / 2);
for(int j = 1; j <= i - 1; j++)
if(d[i] % d[j] == 0)
f[i] = (f[i] - f[j] + MOD) % MOD;
// cerr << d[i] << ' ' << f[i] << endl;
}
int ans = 0;
for(int i = 1; i <= m; i++)
ans = (ans + (long long)d[i] * f[i] / (d[i] & 1 ? 1 : 2)) % MOD;
cout << ans << endl;
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Vasya has got n books, numbered from 1 to n, arranged in a stack. The topmost book has number a_1, the next one β a_2, and so on. The book at the bottom of the stack has number a_n. All numbers are distinct.
Vasya wants to move all the books to his backpack in n steps. During i-th step he wants to move the book number b_i into his backpack. If the book with number b_i is in the stack, he takes this book and all the books above the book b_i, and puts them into the backpack; otherwise he does nothing and begins the next step. For example, if books are arranged in the order [1, 2, 3] (book 1 is the topmost), and Vasya moves the books in the order [2, 1, 3], then during the first step he will move two books (1 and 2), during the second step he will do nothing (since book 1 is already in the backpack), and during the third step β one book (the book number 3). Note that b_1, b_2, ..., b_n are distinct.
Help Vasya! Tell him the number of books he will put into his backpack during each step.
Input
The first line contains one integer n~(1 β€ n β€ 2 β
10^5) β the number of books in the stack.
The second line contains n integers a_1, a_2, ..., a_n~(1 β€ a_i β€ n) denoting the stack of books.
The third line contains n integers b_1, b_2, ..., b_n~(1 β€ b_i β€ n) denoting the steps Vasya is going to perform.
All numbers a_1 ... a_n are distinct, the same goes for b_1 ... b_n.
Output
Print n integers. The i-th of them should be equal to the number of books Vasya moves to his backpack during the i-th step.
Examples
Input
3
1 2 3
2 1 3
Output
2 0 1
Input
5
3 1 4 2 5
4 5 1 3 2
Output
3 2 0 0 0
Input
6
6 5 4 3 2 1
6 5 3 4 2 1
Output
1 1 2 0 1 1
Note
The first example is described in the statement.
In the second example, during the first step Vasya will move the books [3, 1, 4]. After that only books 2 and 5 remain in the stack (2 is above 5). During the second step Vasya will take the books 2 and 5. After that the stack becomes empty, so during next steps Vasya won't move any books.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
stack<int> a, a1;
stack<int> b, b1;
map<int, int> M;
cin >> n;
for (int i = 0; i < n; i++) {
int c;
cin >> c;
a.push(c);
}
for (int i = 0; i < n; i++) {
int c;
cin >> c;
b.push(c);
}
for (int i = 0; i < n; i++) {
int c = a.top();
a.pop();
a1.push(c);
int d = b.top();
b.pop();
b1.push(d);
}
int i = 0;
while (!b1.empty()) {
if (M[b1.top()] == 1) {
cout << "0"
<< " ";
b1.pop();
} else {
int k = 0, found = 0;
while (!a1.empty()) {
if (b1.top() == a1.top()) {
k++;
b1.pop();
M.insert(pair<int, int>(a1.top(), 1));
a1.pop();
found = 1;
break;
}
k++;
M.insert(pair<int, int>(a1.top(), 1));
a1.pop();
}
if (found == 1) cout << k << " ";
}
}
return 0;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
There are N white balls arranged in a row, numbered 1,2,..,N from left to right. AtCoDeer the deer is thinking of painting some of these balls red and blue, while leaving some of them white.
You are given a string s of length K. AtCoDeer performs the following operation for each i from 1 through K in order:
* The i-th operation: Choose a contiguous segment of balls (possibly empty), and paint these balls red if the i-th character in s is `r`; paint them blue if the character is `b`.
Here, if a ball which is already painted is again painted, the color of the ball will be overwritten. However, due to the properties of dyes, it is not possible to paint a white, unpainted ball directly in blue. That is, when the i-th character in s is `b`, the chosen segment must not contain a white ball.
After all the operations, how many different sequences of colors of the balls are possible? Since the count can be large, find it modulo 10^9+7.
Constraints
* 1 β€ N β€ 70
* 1 β€ K β€ 70
* |s| = K
* s consists of `r` and `b`.
* N and K are integers.
Input
Input is given from Standard Input in the following format:
N K
s
Output
Print the number of the different possible sequences of colors of the balls after all the operations, modulo 10^9+7.
Examples
Input
2 2
rb
Output
9
Input
5 2
br
Output
16
Input
7 4
rbrb
Output
1569
Input
70 70
bbrbrrbbrrbbbbrbbrbrrbbrrbbrbrrbrbrbbbbrbbrbrrbbrrbbbbrbbrbrrbbrrbbbbr
Output
841634130
### Response
```cpp
#include <bits/stdc++.h>
const int MAXN = 80;
const int mod = 1000000007;
typedef long long LL;
void reduce(int & x) { x += x >> 31 & mod; }
int mul(int a, int b) { return (LL) a * b % mod; }
int fastpow(int a, int b, int res = 1) {
for (; b; b >>= 1, a = mul(a, a)) if (b & 1) res = mul(res, a);
return res;
}
int li[MAXN];
char buf[MAXN];
int n, K, ans;
const int MAXS = 300;
int tl[MAXN], C[MAXS][MAXS];
int fac[MAXN], inv[MAXN];
void dfs(int S, int rest, int can, int lst) {
if (rest < 0) return ;
memcpy(tl + 1, li + 1, S << 2);
int cur1 = 1, cur2 = 1, cur3 = 1;
for (int i = 1; i <= K; ++i) {
bool ok = false;
if (cur1 <= S && buf[i] == 'r') {
++cur1; ok = true;
}
while (cur2 < cur1 && tl[cur2] == 0) ++cur2;
if (!ok && cur2 + 1 <= cur1 && buf[i] == 'b') {
--tl[cur2++]; ok = true;
}
while (cur2 < cur1 && tl[cur2] == 0) ++cur2;
if (!ok && cur3 < cur2 && tl[cur3]) --tl[cur3];
while (cur3 < cur2 && tl[cur3] == 0) ++cur3;
}
if (cur3 <= S) return ;
int tx = mul(C[can + rest - 1][can - 1], fac[S]);
static int hav[MAXN];
memset(hav, 0, n + 1 << 2);
for (int i = 1; i <= S; ++i) ++hav[li[i]];
for (int i = 0; i <= n; ++i) if (hav[i]) tx = mul(tx, inv[hav[i]]);
reduce(ans += tx - mod);
for (int i = lst; ~i; --i) {
li[S + 1] = i;
dfs(S + 1, rest - std::max(i, 1) * 2 + (S == 0), can + (i + 1) * 2, i);
}
}
int main() {
std::ios_base::sync_with_stdio(false), std::cin.tie(0);
for (int i = 0; i != MAXS; ++i) {
C[i][0] = 1;
for (int j = 1; j <= i; ++j)
reduce(C[i][j] = C[i - 1][j] + C[i - 1][j - 1] - mod);
}
std::cin >> n >> K >> buf + 1;
inv[0] = inv[1] = fac[0] = fac[1] = 1;
for (int i = 2; i <= n; ++i) {
inv[i] = mul(inv[mod % i], mod - mod / i);
fac[i] = mul(fac[i - 1], i);
}
for (int i = 2; i <= n; ++i) inv[i] = mul(inv[i - 1], inv[i]);
dfs(0, n, 1, n);
std::cout << ans << std::endl;
return 0;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
You helped Dima to have a great weekend, but it's time to work. Naturally, Dima, as all other men who have girlfriends, does everything wrong.
Inna and Dima are now in one room. Inna tells Dima off for everything he does in her presence. After Inna tells him off for something, she goes to another room, walks there in circles muttering about how useless her sweetheart is. During that time Dima has time to peacefully complete k - 1 tasks. Then Inna returns and tells Dima off for the next task he does in her presence and goes to another room again. It continues until Dima is through with his tasks.
Overall, Dima has n tasks to do, each task has a unique number from 1 to n. Dima loves order, so he does tasks consecutively, starting from some task. For example, if Dima has 6 tasks to do in total, then, if he starts from the 5-th task, the order is like that: first Dima does the 5-th task, then the 6-th one, then the 1-st one, then the 2-nd one, then the 3-rd one, then the 4-th one.
Inna tells Dima off (only lovingly and appropriately!) so often and systematically that he's very well learned the power with which she tells him off for each task. Help Dima choose the first task so that in total he gets told off with as little power as possible.
Input
The first line of the input contains two integers n, k (1 β€ k β€ n β€ 105). The second line contains n integers a1, a2, ..., an (1 β€ ai β€ 103), where ai is the power Inna tells Dima off with if she is present in the room while he is doing the i-th task.
It is guaranteed that n is divisible by k.
Output
In a single line print the number of the task Dima should start with to get told off with as little power as possible. If there are multiple solutions, print the one with the minimum number of the first task to do.
Examples
Input
6 2
3 2 1 6 5 4
Output
1
Input
10 5
1 3 5 7 9 9 4 1 8 5
Output
3
Note
Explanation of the first example.
If Dima starts from the first task, Inna tells him off with power 3, then Dima can do one more task (as k = 2), then Inna tells him off for the third task with power 1, then she tells him off for the fifth task with power 5. Thus, Dima gets told off with total power 3 + 1 + 5 = 9. If Dima started from the second task, for example, then Inna would tell him off for tasks 2, 4 and 6 with power 2 + 6 + 4 = 12.
Explanation of the second example.
In the second example k = 5, thus, Dima manages to complete 4 tasks in-between the telling off sessions. Thus, Inna tells Dima off for tasks number 1 and 6 (if he starts from 1 or 6), 2 and 7 (if he starts from 2 or 7) and so on. The optimal answer is to start from task 3 or 8, 3 has a smaller number, so the answer is 3.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, k, x, ans1, ans2;
int has[100010];
int main() {
while (scanf("%d%d", &n, &k) != EOF) {
memset(has, 0, sizeof(has));
for (int i = 0; i < n; ++i) {
scanf("%d", &x);
has[i % k] += x;
}
ans1 = 2147483647;
ans2 = -1;
for (int i = 0; i < k; ++i) {
if (has[i] < ans1) {
ans1 = has[i];
ans2 = i + 1;
}
}
printf("%d\n", ans2);
}
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
There are n chips arranged in a circle, numbered from 1 to n.
Initially each chip has black or white color. Then k iterations occur. During each iteration the chips change their colors according to the following rules. For each chip i, three chips are considered: chip i itself and two its neighbours. If the number of white chips among these three is greater than the number of black chips among these three chips, then the chip i becomes white. Otherwise, the chip i becomes black.
Note that for each i from 2 to (n - 1) two neighbouring chips have numbers (i - 1) and (i + 1). The neighbours for the chip i = 1 are n and 2. The neighbours of i = n are (n - 1) and 1.
The following picture describes one iteration with n = 6. The chips 1, 3 and 4 are initially black, and the chips 2, 5 and 6 are white. After the iteration 2, 3 and 4 become black, and 1, 5 and 6 become white.
<image>
Your task is to determine the color of each chip after k iterations.
Input
The first line contains two integers n and k (3 β€ n β€ 200 000, 1 β€ k β€ 10^{9}) β the number of chips and the number of iterations, respectively.
The second line contains a string consisting of n characters "W" and "B". If the i-th character is "W", then the i-th chip is white initially. If the i-th character is "B", then the i-th chip is black initially.
Output
Print a string consisting of n characters "W" and "B". If after k iterations the i-th chip is white, then the i-th character should be "W". Otherwise the i-th character should be "B".
Examples
Input
6 1
BWBBWW
Output
WBBBWW
Input
7 3
WBWBWBW
Output
WWWWWWW
Input
6 4
BWBWBW
Output
BWBWBW
Note
The first example is described in the statement.
The second example: "WBWBWBW" β "WWBWBWW" β "WWWBWWW" β "WWWWWWW". So all chips become white.
The third example: "BWBWBW" β "WBWBWB" β "BWBWBW" β "WBWBWB" β "BWBWBW".
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long poww(long long a, long long b, long long md) {
return (!b ? 1
: (b & 1 ? a * poww(a * a % md, b / 2, md) % md
: poww(a * a % md, b / 2, md) % md));
}
const long long MAXN = 1e6 + 10;
const long long INF = 1e9 + 100;
const long long MOD = 1e9 + 7;
string s;
int n, k, dist[2][MAXN];
queue<int> q[2];
inline int mkey(int k) {
if (k < 0) k += n;
if (k >= n) k -= n;
return k;
}
inline void BFS(int ind) {
while (!q[ind].empty()) {
int v = q[ind].front();
q[ind].pop();
int u1 = mkey(v - 1), u2 = mkey(v + 1);
if (dist[ind][u1] == INF) dist[ind][u1] = dist[ind][v] + 1, q[ind].push(u1);
if (dist[ind][u2] == INF) dist[ind][u2] = dist[ind][v] + 1, q[ind].push(u2);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
fill(dist[0], dist[0] + MAXN, INF);
fill(dist[1], dist[1] + MAXN, INF);
cin >> n >> k;
cin >> s;
for (int i = 0; i < n; i++) {
if (s[i] == s[mkey(i - 1)] || s[i] == s[mkey(i + 1)]) {
if (s[i] == 'B') {
dist[0][i] = 0;
q[0].push(i);
} else {
dist[1][i] = 0;
q[1].push(i);
}
}
}
BFS(0);
BFS(1);
for (int i = 0; i < n; i++) {
if (min(dist[0][i], dist[1][i]) > k) {
if (k & 1) {
if (s[i] == 'B')
cout << 'W';
else
cout << 'B';
} else
cout << s[i];
} else {
if (dist[0][i] < dist[1][i])
cout << 'B';
else if (dist[0][i] == dist[1][i]) {
if (dist[0][i] & 1)
cout << s[i];
else {
if (s[i] == 'B')
cout << 'W';
else
cout << 'B';
}
} else
cout << 'W';
}
}
cout << '\n';
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
One day a highly important task was commissioned to Vasya β writing a program in a night. The program consists of n lines of code. Vasya is already exhausted, so he works like that: first he writes v lines of code, drinks a cup of tea, then he writes as much as <image> lines, drinks another cup of tea, then he writes <image> lines and so on: <image>, <image>, <image>, ...
The expression <image> is regarded as the integral part from dividing number a by number b.
The moment the current value <image> equals 0, Vasya immediately falls asleep and he wakes up only in the morning, when the program should already be finished.
Vasya is wondering, what minimum allowable value v can take to let him write not less than n lines of code before he falls asleep.
Input
The input consists of two integers n and k, separated by spaces β the size of the program in lines and the productivity reduction coefficient, 1 β€ n β€ 109, 2 β€ k β€ 10.
Output
Print the only integer β the minimum value of v that lets Vasya write the program in one night.
Examples
Input
7 2
Output
4
Input
59 9
Output
54
Note
In the first sample the answer is v = 4. Vasya writes the code in the following portions: first 4 lines, then 2, then 1, and then Vasya falls asleep. Thus, he manages to write 4 + 2 + 1 = 7 lines in a night and complete the task.
In the second sample the answer is v = 54. Vasya writes the code in the following portions: 54, 6. The total sum is 54 + 6 = 60, that's even more than n = 59.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long int check(long long int n, long long int k, long long int l) {
long long int a = 0;
if (n / k == 0) {
return 0;
} else {
a = n / k;
k = k * l;
return a + check(n, k, l);
}
}
int main() {
long long int n, k, o, first, last, cur, mincur = 1, minval = 999999999,
tempcur, i;
cin >> n >> k;
if (k >= n) {
cout << n;
return 0;
}
first = 1;
last = n;
while (last - first > 1) {
cur = (first + last) / 2;
o = cur + check(cur, k, k);
if (o >= n) {
minval = o;
mincur = cur;
last = mincur;
} else {
first = cur;
}
}
cout << mincur;
return 0;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
Volodya is an odd boy and his taste is strange as well. It seems to him that a positive integer number is beautiful if and only if it is divisible by each of its nonzero digits. We will not argue with this and just count the quantity of beautiful numbers in given ranges.
Input
The first line of the input contains the number of cases t (1 β€ t β€ 10). Each of the next t lines contains two natural numbers li and ri (1 β€ li β€ ri β€ 9 Β·1018).
Please, do not use %lld specificator to read or write 64-bit integers in C++. It is preffered to use cin (also you may use %I64d).
Output
Output should contain t numbers β answers to the queries, one number per line β quantities of beautiful numbers in given intervals (from li to ri, inclusively).
Examples
Input
1
1 9
Output
9
Input
1
12 15
Output
2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
const int inf = 0x3f3f3f3f;
const long long mod = 2520;
vector<long long> dim;
map<long long, long long> m;
long long f[24][2520][52];
long long gcd(long long a, long long b) {
if (b) {
return gcd(b, a % b);
} else {
return a;
}
}
long long lcm(long long a, long long b) {
if (a == 0) {
return b;
}
if (b == 0) {
return a;
}
if (a < b) {
swap(a, b);
}
return a * b / gcd(a, b);
}
void minit() {
m.clear();
long long count = 0, i;
m[0] = ++count;
for (i = 1; i <= mod; i++) {
if (mod % i == 0 && m.count(mod / i) == 0) {
m[mod / i] = ++count;
}
}
}
long long dfs(long long pos, long long rest, long long lc, long long limit) {
if (!pos) {
if (lc)
return rest % lc ? 0 : 1;
else
return 1;
}
if (!limit && f[pos][rest][m[lc]] != -1) return f[pos][rest][m[lc]];
long long maxx = limit ? dim[pos] : 9, res = 0, i;
for (i = 0; i <= maxx; i++) {
res += dfs(pos - 1, (rest + i * (long long)pow(10, pos - 1)) % mod,
lcm(lc, i), limit && (i == maxx));
}
if (!limit) f[pos][rest][m[lc]] = res;
return res;
}
long long dig(long long x) {
memset(f, -1, sizeof(f));
dim.clear();
dim.push_back(-1);
while (x) {
dim.push_back(x % 10);
x /= 10;
}
return dfs(dim.size() - 1, 0, 0, 1);
}
int main(int argc, char const *argv[]) {
long long t, a, b;
minit();
ios::sync_with_stdio(false);
cin >> t;
while (t--) {
cin >> a >> b;
cout << dig(b) - dig(a - 1) << endl;
}
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
You have been offered a job in a company developing a large social network. Your first task is connected with searching profiles that most probably belong to the same user.
The social network contains n registered profiles, numbered from 1 to n. Some pairs there are friends (the "friendship" relationship is mutual, that is, if i is friends with j, then j is also friends with i). Let's say that profiles i and j (i β j) are doubles, if for any profile k (k β i, k β j) one of the two statements is true: either k is friends with i and j, or k isn't friends with either of them. Also, i and j can be friends or not be friends.
Your task is to count the number of different unordered pairs (i, j), such that the profiles i and j are doubles. Note that the pairs are unordered, that is, pairs (a, b) and (b, a) are considered identical.
Input
The first line contains two space-separated integers n and m (1 β€ n β€ 106, 0 β€ m β€ 106), β the number of profiles and the number of pairs of friends, correspondingly.
Next m lines contains descriptions of pairs of friends in the format "v u", where v and u (1 β€ v, u β€ n, v β u) are numbers of profiles that are friends with each other. It is guaranteed that each unordered pair of friends occurs no more than once and no profile is friends with itself.
Output
Print the single integer β the number of unordered pairs of profiles that are doubles.
Please do not use the %lld specificator to read or write 64-bit integers in Π‘++. It is preferred to use the %I64d specificator.
Examples
Input
3 3
1 2
2 3
1 3
Output
3
Input
3 0
Output
3
Input
4 1
1 3
Output
2
Note
In the first and second sample any two profiles are doubles.
In the third sample the doubles are pairs of profiles (1, 3) and (2, 4).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 7;
vector<int> adj[N], adj1[N];
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
adj1[i] = adj[i];
adj1[i].push_back(i);
sort(adj[i].begin(), adj[i].end());
sort(adj1[i].begin(), adj1[i].end());
}
adj[n + 1].push_back(-1);
adj1[n + 1].push_back(-1);
sort(adj + 1, adj + n + 1);
sort(adj1 + 1, adj1 + n + 1);
long long ans = 0, cnt = 0;
for (int i = 1; i <= n + 1; i++) {
if (adj[i] == adj[i - 1]) {
++cnt;
} else {
ans += cnt * (cnt - 1) / 2;
cnt = 1;
}
}
cnt = 0;
for (int i = 1; i <= n + 1; i++) {
if (adj1[i] == adj1[i - 1]) {
++cnt;
} else {
ans += cnt * (cnt - 1) / 2;
cnt = 1;
}
}
cout << ans << endl;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
There are 2N balls in the xy-plane. The coordinates of the i-th of them is (x_i, y_i). Here, x_i and y_i are integers between 1 and N (inclusive) for all i, and no two balls occupy the same coordinates.
In order to collect these balls, Snuke prepared 2N robots, N of type A and N of type B. Then, he placed the type-A robots at coordinates (1, 0), (2, 0), ..., (N, 0), and the type-B robots at coordinates (0, 1), (0, 2), ..., (0, N), one at each position.
When activated, each type of robot will operate as follows.
* When a type-A robot is activated at coordinates (a, 0), it will move to the position of the ball with the lowest y-coordinate among the balls on the line x = a, collect the ball and deactivate itself. If there is no such ball, it will just deactivate itself without doing anything.
* When a type-B robot is activated at coordinates (0, b), it will move to the position of the ball with the lowest x-coordinate among the balls on the line y = b, collect the ball and deactivate itself. If there is no such ball, it will just deactivate itself without doing anything.
Once deactivated, a robot cannot be activated again. Also, while a robot is operating, no new robot can be activated until the operating robot is deactivated.
When Snuke was about to activate a robot, he noticed that he may fail to collect all the balls, depending on the order of activating the robots.
Among the (2N)! possible orders of activating the robots, find the number of the ones such that all the balls can be collected, modulo 1 000 000 007.
Constraints
* 2 \leq N \leq 10^5
* 1 \leq x_i \leq N
* 1 \leq y_i \leq N
* If i β j, either x_i β x_j or y_i β y_j.
Inputs
Input is given from Standard Input in the following format:
N
x_1 y_1
...
x_{2N} y_{2N}
Outputs
Print the number of the orders of activating the robots such that all the balls can be collected, modulo 1 000 000 007.
Examples
Input
2
1 1
1 2
2 1
2 2
Output
8
Input
4
3 2
1 2
4 1
4 2
2 2
4 4
2 1
1 3
Output
7392
Input
4
1 1
2 2
3 3
4 4
1 2
2 1
3 4
4 3
Output
4480
Input
8
6 2
5 1
6 8
7 8
6 5
5 7
4 3
1 4
7 6
8 3
2 8
3 6
3 2
8 5
1 5
5 8
Output
82060779
Input
3
1 1
1 2
1 3
2 1
2 2
2 3
Output
0
### Response
```cpp
#include <iostream>
#include <stdio.h>
#include <math.h>
#include <string.h>
#include <time.h>
#include <stdlib.h>
#include <string>
#include <bitset>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <algorithm>
#include <sstream>
#include <stack>
#include <iomanip>
using namespace std;
#define pb push_back
#define mp make_pair
typedef pair<int,int> pii;
typedef long long ll;
typedef double ld;
typedef vector<int> vi;
#define fi first
#define se second
#define fe first
#define FO(x) {freopen(#x".in","r",stdin);freopen(#x".out","w",stdout);}
#define Edg int M=0,fst[SZ],vb[SZ],nxt[SZ];void ad_de(int a,int b){++M;nxt[M]=fst[a];fst[a]=M;vb[M]=b;}void adde(int a,int b){ad_de(a,b);ad_de(b,a);}
#define Edgc int M=0,fst[SZ],vb[SZ],nxt[SZ],vc[SZ];void ad_de(int a,int b,int c){++M;nxt[M]=fst[a];fst[a]=M;vb[M]=b;vc[M]=c;}void adde(int a,int b,int c){ad_de(a,b,c);ad_de(b,a,c);}
#define es(x,e) (int e=fst[x];e;e=nxt[e])
#define esb(x,e,b) (int e=fst[x],b=vb[e];e;e=nxt[e],b=vb[e])
#define VIZ {printf("digraph G{\n"); for(int i=1;i<=n;i++) for es(i,e) printf("%d->%d;\n",i,vb[e]); puts("}");}
#define VIZ2 {printf("graph G{\n"); for(int i=1;i<=n;i++) for es(i,e) if(vb[e]>=i)printf("%d--%d;\n",i,vb[e]); puts("}");}
#define SZ 666666
int n,fa[SZ]; Edg
ll fac[SZ],rfac[SZ];
const int MOD=1e9+7;
namespace Topo
{
Edg
bool ro[SZ];
int sz[SZ];
ll wo(int x)
{
sz[x]=0; ll ans=1;
for esb(x,e,b)
{
ans*=wo(b); ans%=MOD;
sz[x]+=sz[b];
ans=ans*fac[sz[x]]%MOD*
rfac[sz[b]]%MOD*rfac[sz[x]-sz[b]]%MOD;
}
++sz[x]; return ans;
}
}
bool vis[SZ];
vector<int> cm,cyc;
int edg=0,cx,cyy,ys[SZ];
void dfs(int x)
{
vis[x]=1; cm.pb(x);
for esb(x,e,b) ++edg;
for esb(x,e,b) if(!vis[b])
{
fa[b]=x; dfs(b);
}
else
{
if(b!=fa[x]) cx=x,cyy=b;
}
}
bool cy[SZ]; int ff[SZ];
void d2(int x,int f=0)
{
for esb(x,e,b) if(b!=f&&!cy[b])
{
ff[b]=x; d2(b,x);
}
}
int vv[SZ],pp=0;
ll qp(ll a,ll b)
{
ll x=1;
while(b)
{
if(b&1) x=x*a%MOD;
a=a*a%MOD; b>>=1;
}
return x;
}
int main()
{
fac[0]=1;
for(int i=1;i<SZ;++i) fac[i]=fac[i-1]*i%MOD;
rfac[SZ-1]=qp(fac[SZ-1],MOD-2);
for(int i=SZ-1;i>=1;--i)
rfac[i-1]=rfac[i]*i%MOD;
scanf("%d",&n);
for(int i=1;i<=n+n;++i)
{
int a,b;
scanf("%d%d",&a,&b);
adde(a,b+n);
}
ll ans=1; int ss=0;
for(int i=1;i<=n+n;++i) if(!vis[i])
{
cm.clear(); cyc.clear(); fa[i]=0; edg=0; dfs(i);
if(edg!=cm.size()*2)
{
puts("0");
return 0;
}
++pp;
for(int a=cx;a;a=fa[a]) vv[a]=pp;
int rs=0; vector<int> ts;
for(int a=cyy;a;a=fa[a])
{
ts.pb(a);
if(vv[a]==pp) {rs=a; break;}
}
for(int a=cx;a!=rs;a=fa[a])
cyc.pb(a);
for(int i=int(ts.size())-1;i>=0;--i)
cyc.pb(ts[i]);
for(auto s:cyc) cy[s]=1;
for(auto s:cyc) d2(s);
for(auto g:cm) if(!cy[g])
ys[g]=ff[g];
ll a1=1,a2=1;
for(int i=0;i<cyc.size();++i)
ys[cyc[i]]=cyc[(i+1)%cyc.size()];
for(auto s:cm) Topo::fst[s]=0,Topo::ro[s]=1;
for(auto x:cm)
for esb(x,e,b) if(b<ys[x])
Topo::ad_de(x,b),Topo::ro[b]=0;
int sp;
sp=0;
for(auto x:cm)
if(Topo::ro[x])
{
a1=a1*Topo::wo(x)%MOD;
int s=Topo::sz[x]; sp+=s;
a1=a1*fac[sp]%MOD*rfac[s]%MOD
*rfac[sp-s]%MOD;
}
for(int i=0;i<cyc.size();++i)
ys[cyc[(i+1)%cyc.size()]]=cyc[i];
for(auto s:cm) Topo::fst[s]=0,Topo::ro[s]=1;
for(auto x:cm)
for esb(x,e,b) if(b<ys[x])
Topo::ad_de(x,b),Topo::ro[b]=0;
sp=0;
for(auto x:cm)
if(Topo::ro[x])
{
a2=a2*Topo::wo(x)%MOD;
int s=Topo::sz[x]; sp+=s;
a2=a2*fac[sp]%MOD*rfac[s]%MOD
*rfac[sp-s]%MOD;
}
ans=ans*(a1+a2)%MOD;
int cs=cm.size(); ss+=cs;
ans=ans*fac[ss]%MOD*rfac[cs]%MOD*rfac[ss-cs]%MOD;
}
ans=(ans%MOD+MOD)%MOD;
cout<<ans<<"\n";
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
It is known that fleas in Berland can jump only vertically and horizontally, and the length of the jump is always equal to s centimeters. A flea has found herself at the center of some cell of the checked board of the size n Γ m centimeters (each cell is 1 Γ 1 centimeters). She can jump as she wishes for an arbitrary number of times, she can even visit a cell more than once. The only restriction is that she cannot jump out of the board.
The flea can count the amount of cells that she can reach from the starting position (x, y). Let's denote this amount by dx, y. Your task is to find the number of such starting positions (x, y), which have the maximum possible value of dx, y.
Input
The first line contains three integers n, m, s (1 β€ n, m, s β€ 106) β length of the board, width of the board and length of the flea's jump.
Output
Output the only integer β the number of the required starting positions of the flea.
Examples
Input
2 3 1000000
Output
6
Input
3 3 2
Output
4
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long a, b, c, d, e, t1, t2, t3;
long long la, lb, lc;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, m, s;
cin >> n >> m >> s;
a = 0;
b = 0;
long long i = 0;
c = 1;
if (s <= n) {
a = n % s;
++a;
while (i < n) {
if (i + s < n) {
i += s;
++c;
} else {
a = n - (i + 1);
++a;
break;
}
}
} else {
c = n;
a = 1;
}
i = 0;
d = 1;
if (s <= m) {
b = m % s;
++b;
while (i < m) {
if (i + s < m) {
i += s;
++d;
} else {
b = m - (i + 1);
++b;
break;
}
}
} else {
d = m;
b = 1;
}
e = c * d;
t1 = a * b;
cout << t1 * e;
return 0;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
In Doodle Jump the aim is to guide a four-legged creature called "The Doodler" up a never-ending series of platforms without falling. β Wikipedia.
It is a very popular game and xiaodao likes it very much. One day when playing the game she wondered whether there exists a platform that the doodler couldn't reach due to the limits of its jumping ability. Consider the following problem.
There are n platforms. The height of the x-th (1 β€ x β€ n) platform is aΒ·x mod p, where a and p are positive co-prime integers. The maximum possible height of a Doodler's jump is h. That is, it can jump from height h1 to height h2 (h1 < h2) if h2 - h1 β€ h. Initially, the Doodler is on the ground, the height of which is 0. The question is whether it can reach the highest platform or not.
For example, when a = 7, n = 4, p = 12, h = 2, the heights of the platforms are 7, 2, 9, 4 as in the picture below. With the first jump the Doodler can jump to the platform at height 2, with the second one the Doodler can jump to the platform at height 4, but then it can't jump to any of the higher platforms. So, it can't reach the highest platform.
<image>
User xiaodao thought about the problem for a long time but didn't solve it, so she asks you for help. Also, she has a lot of instances of the problem. Your task is solve all of these instances.
Input
The first line contains an integer t (1 β€ t β€ 104) β the number of problem instances. Each of the next t lines contains four integers a, n, p and h (1 β€ a β€ 109, 1 β€ n < p β€ 109, 0 β€ h β€ 109). It's guaranteed that a and p are co-prime.
Output
For each problem instance, if the Doodler can reach the highest platform, output "YES", otherwise output "NO".
Examples
Input
3
7 4 12 2
7 1 9 4
7 4 12 3
Output
NO
NO
YES
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int T;
int F(int a, int n, int p) {
long long t = (long long)a * n / p;
if (!t) return max(a, p - a * n);
return F(a - p % a, t - ((long long)a * n % p < (p / a - 1) * a), a);
}
int a, n, p, h;
void solve() {
scanf("%d%d%d%d", &a, &n, &p, &h);
a %= p;
puts(((long long)a * n < p ? a : F(a, n, p)) <= h ? "YES" : "NO");
}
int main() {
scanf("%d", &T);
while (T--) solve();
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
Π‘ity N. has a huge problem with roads, food and IT-infrastructure. In total the city has n junctions, some pairs of them are connected by bidirectional roads. The road network consists of n - 1 roads, you can get from any junction to any other one by these roads. Yes, you're right β the road network forms an undirected tree.
Recently, the Mayor came up with a way that eliminates the problems with the food and the IT-infrastructure at the same time! He decided to put at the city junctions restaurants of two well-known cafe networks for IT professionals: "iMac D0naldz" and "Burger Bing". Since the network owners are not friends, it is strictly prohibited to place two restaurants of different networks on neighboring junctions. There are other requirements. Here's the full list:
* each junction must have at most one restaurant;
* each restaurant belongs either to "iMac D0naldz", or to "Burger Bing";
* each network should build at least one restaurant;
* there is no pair of junctions that are connected by a road and contains restaurants of different networks.
The Mayor is going to take a large tax from each restaurant, so he is interested in making the total number of the restaurants as large as possible.
Help the Mayor to analyze the situation. Find all such pairs of (a, b) that a restaurants can belong to "iMac D0naldz", b restaurants can belong to "Burger Bing", and the sum of a + b is as large as possible.
Input
The first input line contains integer n (3 β€ n β€ 5000) β the number of junctions in the city. Next n - 1 lines list all roads one per line. Each road is given as a pair of integers xi, yi (1 β€ xi, yi β€ n) β the indexes of connected junctions. Consider the junctions indexed from 1 to n.
It is guaranteed that the given road network is represented by an undirected tree with n vertexes.
Output
Print on the first line integer z β the number of sought pairs. Then print all sought pairs (a, b) in the order of increasing of the first component a.
Examples
Input
5
1 2
2 3
3 4
4 5
Output
3
1 3
2 2
3 1
Input
10
1 2
2 3
3 4
5 6
6 7
7 4
8 9
9 10
10 4
Output
6
1 8
2 7
3 6
6 3
7 2
8 1
Note
The figure below shows the answers to the first test case. The junctions with "iMac D0naldz" restaurants are marked red and "Burger Bing" restaurants are marked blue.
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 5001;
vector<int> tree[N];
int subtree[N]{0};
bool exist[N][N]{false};
bool ans[N]{false};
int n;
void dfs(int par = 0, int child = 1) {
subtree[child] = 1;
exist[child][0] = true;
for (int kid : tree[child]) {
if (par == kid) continue;
dfs(child, kid);
subtree[child] += subtree[kid];
for (int i = n - 1; i >= 0; i--) {
if (exist[child][i]) exist[child][i + subtree[kid]] = true;
}
}
for (int i = 1; i <= n - 2; i++) {
if (exist[child][i]) exist[child][n - 1 - i] = true;
}
for (int i = 1; i <= n - 2; i++) {
if (exist[child][i]) ans[i] = true;
}
}
int main() {
cin >> n;
for (int i = 0, v, u; i < n - 1 && cin >> u >> v; i++)
tree[u].push_back(v), tree[v].push_back(u);
dfs();
int cnt = 0;
vector<int> final_ans;
for (int i = 1; i <= n - 2; i++)
if (ans[i]) final_ans.push_back(i);
cout << final_ans.size() << "\n";
for (int i : final_ans) cout << i << " " << n - i - 1 << "\n";
return 0;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
Artem is building a new robot. He has a matrix a consisting of n rows and m columns. The cell located on the i-th row from the top and the j-th column from the left has a value a_{i,j} written in it.
If two adjacent cells contain the same value, the robot will break. A matrix is called good if no two adjacent cells contain the same value, where two cells are called adjacent if they share a side.
Artem wants to increment the values in some cells by one to make a good.
More formally, find a good matrix b that satisfies the following condition β
* For all valid (i,j), either b_{i,j} = a_{i,j} or b_{i,j} = a_{i,j}+1.
For the constraints of this problem, it can be shown that such a matrix b always exists. If there are several such tables, you can output any of them. Please note that you do not have to minimize the number of increments.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 10). Description of the test cases follows.
The first line of each test case contains two integers n, m (1 β€ n β€ 100, 1 β€ m β€ 100) β the number of rows and columns, respectively.
The following n lines each contain m integers. The j-th integer in the i-th line is a_{i,j} (1 β€ a_{i,j} β€ 10^9).
Output
For each case, output n lines each containing m integers. The j-th integer in the i-th line is b_{i,j}.
Example
Input
3
3 2
1 2
4 5
7 8
2 2
1 1
3 3
2 2
1 3
2 2
Output
1 2
5 6
7 8
2 1
4 3
2 4
3 2
Note
In all the cases, you can verify that no two adjacent cells have the same value and that b is the same as a with some values incremented by one.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <class T>
using v = vector<T>;
template <class T>
using vv = vector<v<T>>;
template <class T>
using pri = priority_queue<T>;
template <class T>
using rpi = priority_queue<T, v<T>, greater<T>>;
template <class T>
inline void rd(T& a) {
cin >> a;
}
template <class T>
inline void rd(v<T>& a, long long n) {
T v;
for (long long i = (long long)0; i < (long long)n; i++) {
cin >> v;
a[i] = v;
}
}
template <class T>
inline void rd(vv<T>& a, long long n, long long m) {
for (long long i = (long long)0; i < (long long)n; i++) {
rd(a[i], m);
}
}
template <class T>
inline void print(T a) {
cout << a << '\n';
}
template <class T>
inline void print(v<T> a) {
for (auto x : a) cout << x << ' ';
cout << '\n';
}
template <class T>
inline void print(vv<T> a) {
for (auto x : a) print(x);
}
template <class T, class U>
inline void chmax(T& a, U b) {
if (a < b) a = b;
}
template <class T, class U>
inline void chmin(T& a, U b) {
if (a > b) a = b;
}
template <class T, class... Args>
inline void rd(T& a, Args&... args) {
cin >> a;
rd(args...);
}
inline long long mintwo(long long n) { return __builtin_ctzll(n); }
inline long long maxtwo(long long n) { return (long long)log2(n); }
inline long long onebits(long long n) { return __builtin_popcountll(n); }
inline long double pdiv(long long a, long long b) {
return (1.0 * a) / (1.0 * b);
}
inline void POW(long long a, long long b, long long& r) {
for (long long e = b; e > 0; e >>= 1, a *= a) r *= ((e & 1) ? a : 1);
}
inline void chxor(long long& a, long long b) { a = a ^ b; }
inline void mangekyo();
inline void subl() {}
long double _c;
using i32 = int32_t;
using namespace std;
int32_t main() {
mangekyo();
long long _t;
rd(_t);
for (long long _ = (long long)1; _ < (long long)_t + 1; _++) {
long long n, m;
rd(n, m);
vv<long long> a(n, v<long long>(m));
rd(a, n, m);
cerr << "Test #" << _ << ": " << '\n';
;
for (long long i = (long long)0; i < (long long)n; i++) {
for (long long j = (long long)0; j < (long long)m; j++) {
if ((i + j) & 1) {
if (!(a[i][j] & 1)) a[i][j]++;
} else {
if (a[i][j] & 1) a[i][j]++;
}
}
}
print(a);
}
cerr << "Time: " << ((clock() - _c) / CLOCKS_PER_SEC);
;
return 0;
}
void mangekyo() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
srand(time(NULL));
_c = clock();
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
Let f_{x} = c^{2x-6} β
f_{x-1} β
f_{x-2} β
f_{x-3} for x β₯ 4.
You have given integers n, f_{1}, f_{2}, f_{3}, and c. Find f_{n} mod (10^{9}+7).
Input
The only line contains five integers n, f_{1}, f_{2}, f_{3}, and c (4 β€ n β€ 10^{18}, 1 β€ f_{1}, f_{2}, f_{3}, c β€ 10^{9}).
Output
Print f_{n} mod (10^{9} + 7).
Examples
Input
5 1 2 5 3
Output
72900
Input
17 97 41 37 11
Output
317451037
Note
In the first example, f_{4} = 90, f_{5} = 72900.
In the second example, f_{17} β 2.28 Γ 10^{29587}.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
vector<vector<long long>> operator*(vector<vector<long long>> a,
vector<vector<long long>> b) {
if (a[0].size() != b.size()) swap(a, b);
int n = a.size();
int m = b[0].size();
vector<vector<long long>> c(n, vector<long long>(m));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
for (int k = 0; k < b.size(); k++) {
(c[i][j] += a[i][k] * b[k][j]) %= (mod - 1);
}
}
}
return c;
}
vector<vector<long long>> bpow(vector<vector<long long>> a, long long b) {
assert(b >= 0);
if (b == 1) return a;
if (b & 1) return a * bpow(a, b - 1);
auto t = bpow(a, b / 2);
return t * t;
}
long long bpow(long long a, long long b) {
if (!b) return 1;
if (b & 1) return a * bpow(a, b - 1) % mod;
long long t = bpow(a, b / 2);
return t * t % mod;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, f1, f2, f3, c;
cin >> n >> f1 >> f2 >> f3 >> c;
vector<vector<long long>> d = {{0, 1, 0}, {0, 0, 1}, {1, 1, 1}};
d = bpow(d, n - 3);
vector<vector<long long>> v1 = {{1}, {0}, {0}};
vector<vector<long long>> v2 = {{0}, {1}, {0}};
vector<vector<long long>> v3 = {{0}, {0}, {1}};
long long deg1 = (v1 * d).back().back(), deg2 = (v2 * d).back().back(),
deg3 = (v3 * d).back().back();
vector<vector<long long>> C = {{0, 1, 0, 0, 0},
{0, 0, 1, 0, 0},
{1, 1, 1, 2, -6},
{0, 0, 0, 1, 1},
{0, 0, 0, 0, 1}};
C = bpow(C, n - 3);
C = C * (vector<vector<long long>>){{0}, {0}, {0}, {4}, {1}};
cout << bpow(c, C[2][0]) * bpow(f1, deg1) % mod * bpow(f2, deg2) % mod *
bpow(f3, deg3) % mod;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
You have a positive integer m and a non-negative integer s. Your task is to find the smallest and the largest of the numbers that have length m and sum of digits s. The required numbers should be non-negative integers written in the decimal base without leading zeroes.
Input
The single line of the input contains a pair of integers m, s (1 β€ m β€ 100, 0 β€ s β€ 900) β the length and the sum of the digits of the required numbers.
Output
In the output print the pair of the required non-negative integer numbers β first the minimum possible number, then β the maximum possible number. If no numbers satisfying conditions required exist, print the pair of numbers "-1 -1" (without the quotes).
Examples
Input
2 15
Output
69 96
Input
3 0
Output
-1 -1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, s, i, j, k, l, x;
int arr[105];
int arr1[105];
cin >> m >> s;
l = m * 9;
if (m > 1 && s == 0) {
cout << "-1"
<< " "
<< "-1" << endl;
} else if (s > l) {
cout << "-1"
<< " "
<< "-1" << endl;
} else if (m == 1 && s == 0) {
cout << "0"
<< " "
<< "0" << endl;
} else {
x = s;
for (i = 1; i <= m; i++) {
if (s >= 9) {
arr[i] = 9;
s = s - 9;
} else if (s == 0) {
arr[i] = 0;
} else {
arr[i] = s;
s = 0;
}
}
for (i = m; i >= 1; i--) {
if (x > 9) {
arr1[i] = 9;
x = x - 9;
} else if (x == 1 && i > 1) {
arr1[i] = 0;
} else if (x <= 9 && i > 1) {
x = x - 1;
arr1[i] = x;
x = 1;
} else if (i == 1) {
arr1[i] = x;
}
}
for (i = 1; i <= m; i++) {
cout << arr1[i];
}
cout << " ";
for (i = 1; i <= m; i++) {
cout << arr[i];
}
cout << endl;
}
return 0;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
There are n seats in the train's car and there is exactly one passenger occupying every seat. The seats are numbered from 1 to n from left to right. The trip is long, so each passenger will become hungry at some moment of time and will go to take boiled water for his noodles. The person at seat i (1 β€ i β€ n) will decide to go for boiled water at minute t_i.
Tank with a boiled water is located to the left of the 1-st seat. In case too many passengers will go for boiled water simultaneously, they will form a queue, since there can be only one passenger using the tank at each particular moment of time. Each passenger uses the tank for exactly p minutes. We assume that the time it takes passengers to go from their seat to the tank is negligibly small.
Nobody likes to stand in a queue. So when the passenger occupying the i-th seat wants to go for a boiled water, he will first take a look on all seats from 1 to i - 1. In case at least one of those seats is empty, he assumes that those people are standing in a queue right now, so he would be better seating for the time being. However, at the very first moment he observes that all seats with numbers smaller than i are busy, he will go to the tank.
There is an unspoken rule, that in case at some moment several people can go to the tank, than only the leftmost of them (that is, seating on the seat with smallest number) will go to the tank, while all others will wait for the next moment.
Your goal is to find for each passenger, when he will receive the boiled water for his noodles.
Input
The first line contains integers n and p (1 β€ n β€ 100 000, 1 β€ p β€ 10^9) β the number of people and the amount of time one person uses the tank.
The second line contains n integers t_1, t_2, ..., t_n (0 β€ t_i β€ 10^9) β the moments when the corresponding passenger will go for the boiled water.
Output
Print n integers, where i-th of them is the time moment the passenger on i-th seat will receive his boiled water.
Example
Input
5 314
0 310 942 628 0
Output
314 628 1256 942 1570
Note
Consider the example.
At the 0-th minute there were two passengers willing to go for a water, passenger 1 and 5, so the first passenger has gone first, and returned at the 314-th minute. At this moment the passenger 2 was already willing to go for the water, so the passenger 2 has gone next, and so on. In the end, 5-th passenger was last to receive the boiled water.
### Response
```cpp
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("avx2")
#pragma GCC target(sse, sse2, sse3, ssse3, sse4, popcnt, tune = native)
using namespace std;
const long long inf = 1e17 + 47;
const long long MAXN = 1e5 + 47;
struct fenwik {
vector<long long> ex;
long long n;
fenwik(long long p) {
n = p;
ex.resize(n, 0);
}
void change(long long p, long long add) {
for (long long i = p; i < n; i = (i | (i + 1))) {
ex[i] += add;
}
}
long long get(long long r) {
long long res = 0;
for (long long i = r; i >= 0; i = (i & (i + 1)) - 1) res += ex[i];
return res;
}
long long get(long long l, long long r) { return get(r) - get(l - 1); }
};
long long n, p;
fenwik Q(MAXN);
vector<pair<long long, long long> > event;
void read() {
cin >> n >> p;
event.resize(n);
for (long long i = 0; i < n; i++) {
cin >> event[i].first;
event[i].second = i;
}
sort(event.begin(), event.end());
reverse(event.begin(), event.end());
}
long long get_q(deque<pair<long long, long long> > &q) {
if ((long long)(q.size()) == 0) return inf;
return q.front().second;
}
long long get_p() {
if ((long long)(event.size()) == 0) return inf;
return event.back().first;
}
void solve() {
deque<pair<long long, long long> > q;
set<long long> one_step;
vector<long long> ans(n, -1);
while (true) {
long long fq = get_q(q), fp = get_p();
if (fq == fp && fq == inf) break;
if (fp <= fq) {
if (Q.get(event.back().second) == 0) {
if ((long long)(q.size()) == 0)
q.push_back({event.back().second, event.back().first + p});
else
q.push_back({event.back().second, q.back().second + p});
Q.change(event.back().second, +1);
} else {
one_step.insert(event.back().second);
}
event.pop_back();
continue;
}
long long p1 = q.front().first, tm = q.front().second;
q.pop_front();
ans[p1] = tm;
Q.change(p1, -1);
if ((long long)(one_step.size()) == 0) continue;
long long step = *(one_step.begin());
if (Q.get(step) == 0) {
one_step.erase(one_step.begin());
if ((long long)(q.size()) == 0)
q.push_back({step, tm + p});
else
q.push_back({step, q.back().second + p});
Q.change(step, +1);
}
}
for (long long &p : ans) cout << p << " ";
cout << "\n";
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long t = 1;
while (t--) {
read();
solve();
}
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
Vasya is developing his own programming language VPL (Vasya Programming Language). Right now he is busy making the system of exceptions. He thinks that the system of exceptions must function like that.
The exceptions are processed by try-catch-blocks. There are two operators that work with the blocks:
1. The try operator. It opens a new try-catch-block.
2. The catch(<exception_type>, <message>) operator. It closes the try-catch-block that was started last and haven't yet been closed. This block can be activated only via exception of type <exception_type>. When we activate this block, the screen displays the <message>. If at the given moment there is no open try-catch-block, then we can't use the catch operator.
The exceptions can occur in the program in only one case: when we use the throw operator. The throw(<exception_type>) operator creates the exception of the given type.
Let's suggest that as a result of using some throw operator the program created an exception of type a. In this case a try-catch-block is activated, such that this block's try operator was described in the program earlier than the used throw operator. Also, this block's catch operator was given an exception type a as a parameter and this block's catch operator is described later that the used throw operator. If there are several such try-catch-blocks, then the system activates the block whose catch operator occurs earlier than others. If no try-catch-block was activated, then the screen displays message "Unhandled Exception".
To test the system, Vasya wrote a program that contains only try, catch and throw operators, one line contains no more than one operator, the whole program contains exactly one throw operator.
Your task is: given a program in VPL, determine, what message will be displayed on the screen.
Input
The first line contains a single integer: n (1 β€ n β€ 105) the number of lines in the program. Next n lines contain the program in language VPL. Each line contains no more than one operator. It means that input file can contain empty lines and lines, consisting only of spaces.
The program contains only operators try, catch and throw. It is guaranteed that the program is correct. It means that each started try-catch-block was closed, the catch operators aren't used unless there is an open try-catch-block. The program has exactly one throw operator. The program may have spaces at the beginning of a line, at the end of a line, before and after a bracket, a comma or a quote mark.
The exception type is a nonempty string, that consists only of upper and lower case english letters. The length of the string does not exceed 20 symbols. Message is a nonempty string, that consists only of upper and lower case english letters, digits and spaces. Message is surrounded with quote marks. Quote marks shouldn't be printed. The length of the string does not exceed 20 symbols.
Length of any line in the input file does not exceed 50 symbols.
Output
Print the message the screen will show after the given program is executed.
Examples
Input
8
try
try
throw ( AE )
catch ( BE, "BE in line 3")
try
catch(AE, "AE in line 5")
catch(AE,"AE somewhere")
Output
AE somewhere
Input
8
try
try
throw ( AE )
catch ( AE, "AE in line 3")
try
catch(BE, "BE in line 5")
catch(AE,"AE somewhere")
Output
AE in line 3
Input
8
try
try
throw ( CE )
catch ( BE, "BE in line 3")
try
catch(AE, "AE in line 5")
catch(AE,"AE somewhere")
Output
Unhandled Exception
Note
In the first sample there are 2 try-catch-blocks such that try operator is described earlier than throw operator and catch operator is described later than throw operator: try-catch(BE,"BE in line 3") and try-catch(AE,"AE somewhere"). Exception type is AE, so the second block will be activated, because operator catch(AE,"AE somewhere") has exception type AE as parameter and operator catch(BE,"BE in line 3") has exception type BE.
In the second sample there are 2 try-catch-blocks such that try operator is described earlier than throw operator and catch operator is described later than throw operator: try-catch(AE,"AE in line 3") and try-catch(AE,"AE somewhere"). Exception type is AE, so both blocks can be activated, but only the first one will be activated, because operator catch(AE,"AE in line 3") is described earlier than catch(AE,"AE somewhere")
In the third sample there is no blocks that can be activated by an exception of type CE.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, l, level, openin;
string s, t, com, var, str, message;
int main() {
int i, j, quote;
quote = 0;
scanf("%d", &n);
getchar();
for (i = 0; i < n; i++) {
getline(cin, s);
t = "";
for (j = 0; j < s.length(); j++)
if (s[j] != ' ' || quote == 1) {
if (s[j] == '"') quote = (quote + 1) % 2;
t.append(1, s[j]);
}
l = t.length();
com = "";
for (j = 0; j < l; j++) {
com = com + t[j];
if (com == "try") {
com = "";
++level;
}
if (com == "throw") {
com = "";
++j;
openin = level;
while (t[j] != ')' && j < l) {
if (t[j] != '(') var.append(1, t[j]);
++j;
}
}
if (com == "catch") {
com = "";
++j;
str = "";
message = "";
while (t[j] != ',' && j < l) {
if (t[j] != '(') str.append(1, t[j]);
++j;
}
++j;
while (t[j] != ')' && j < l) {
if (t[j] != '"') message.append(1, t[j]);
++j;
}
if (openin == level) {
if (str == var) {
cout << message << endl;
return 0;
}
--openin;
}
--level;
}
}
}
puts("Unhandled Exception");
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
You are given a tree with n nodes. You have to write non-negative integers on its edges so that the following condition would be satisfied:
For every two nodes i, j, look at the path between them and count the sum of numbers on the edges of this path. Write all obtained sums on the blackboard. Then every integer from 1 to β (2n^2)/(9) β has to be written on the blackboard at least once.
It is guaranteed that such an arrangement exists.
Input
The first line contains a single integer n (1 β€ n β€ 1000) β the number of nodes.
Each of the next n-1 lines contains two integers u and v (1 β€ u, v β€ n, u β v), meaning that there is an edge between nodes u and v. It is guaranteed that these edges form a tree.
Output
Output n-1 lines, each of form u v x (0 β€ x β€ 10^6), which will mean that you wrote number x on the edge between u, v.
Set of edges (u, v) has to coincide with the set of edges of the input graph, but you can output edges in any order. You can also output ends of edges in an order different from the order in input.
Examples
Input
3
2 3
2 1
Output
3 2 1
1 2 2
Input
4
2 4
2 3
2 1
Output
4 2 1
3 2 2
1 2 3
Input
5
1 2
1 3
1 4
2 5
Output
2 1 1
5 2 1
3 1 3
4 1 6
Note
In the first example, distance between nodes 1 and 2 is equal to 2, between nodes 2 and 3 to 1, between 1 and 3 to 3.
In the third example, numbers from 1 to 9 (inclusive) will be written on the blackboard, while we need just from 1 to 5 to pass the test.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int res = 0, f = 1;
char c = getchar();
while (!(c >= '0' && c <= '9') && c != '-') c = getchar();
if (c == '-') f = -1, c = getchar();
while ((c >= '0' && c <= '9'))
res = (res << 3) + (res << 1) + (c ^ 48), c = getchar();
return res * f;
}
const int maxn = 1e4 + 10;
int n, e[maxn << 1][2], h[maxn];
void add_edge(int u, int v, int i) {
e[i][0] = v, e[i][1] = h[u];
h[u] = i;
return;
}
int siz[maxn], dp[maxn], y = 1e9, cen;
void dfs(int u, int fa) {
siz[u] = 1;
for (int i = h[u]; i; i = e[i][1]) {
int v = e[i][0];
if (v != fa) {
dfs(v, u);
siz[u] += siz[v];
dp[u] = max(dp[u], siz[v]);
}
}
dp[u] = max(dp[u], n - siz[u]);
if (dp[u] < y) cen = u, y = dp[u];
return;
}
pair<int, int> a[maxn];
int cnt;
int num, fa[maxn], ans[maxn];
void work(int u, int sta, int w) {
siz[u] = 1;
ans[u] = sta * w;
sta = 1;
for (int i = h[u]; i; i = e[i][1]) {
int v = e[i][0];
if (v != fa[u]) {
fa[v] = u;
work(v, sta, w);
siz[u] += siz[v];
sta += siz[v];
}
}
}
int main() {
n = read();
for (int i = 1, u, v; i < n; i++) {
u = read(), v = read();
add_edge(u, v, i * 2);
add_edge(v, u, i * 2 + 1);
}
dfs(1, 0);
for (int i = h[cen]; i; i = e[i][1]) {
int v = e[i][0];
if (siz[v] < siz[cen])
a[++cnt] = make_pair(siz[v], v);
else
a[++cnt] = make_pair(n - siz[cen], v);
}
sort(a + 1, a + cnt + 1);
int mx = -1, bd = 0, tmp = 0, t;
for (int i = 1; i <= cnt; i++) {
tmp += a[i].first;
if (tmp * (n - tmp - 1) > mx) mx = tmp * (n - tmp - 1), t = tmp, bd = i;
}
tmp = 1;
for (int i = 1; i <= bd; i++) {
fa[a[i].second] = cen;
work(a[i].second, tmp, 1);
tmp += a[i].first;
}
tmp = 1;
for (int i = bd + 1; i <= cnt; i++) {
fa[a[i].second] = cen;
work(a[i].second, tmp, t + 1);
tmp += a[i].first;
}
for (int i = 1; i <= n; i++)
if (i != cen) printf("%d %d %d\n", i, fa[i], ans[i]);
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
Student Andrey has been skipping physical education lessons for the whole term, and now he must somehow get a passing grade on this subject. Obviously, it is impossible to do this by legal means, but Andrey doesn't give up. Having obtained an empty certificate from a local hospital, he is going to use his knowledge of local doctor's handwriting to make a counterfeit certificate of illness. However, after writing most of the certificate, Andrey suddenly discovered that doctor's signature is impossible to forge. Or is it?
For simplicity, the signature is represented as an nΓ m grid, where every cell is either filled with ink or empty. Andrey's pen can fill a 3Γ3 square without its central cell if it is completely contained inside the grid, as shown below.
xxx
x.x
xxx
Determine whether is it possible to forge the signature on an empty nΓ m grid.
Input
The first line of input contains two integers n and m (3 β€ n, m β€ 1000).
Then n lines follow, each contains m characters. Each of the characters is either '.', representing an empty cell, or '#', representing an ink filled cell.
Output
If Andrey can forge the signature, output "YES". Otherwise output "NO".
You can print each letter in any case (upper or lower).
Examples
Input
3 3
###
#.#
###
Output
YES
Input
3 3
###
###
###
Output
NO
Input
4 3
###
###
###
###
Output
YES
Input
5 7
.......
.#####.
.#.#.#.
.#####.
.......
Output
YES
Note
In the first sample Andrey can paint the border of the square with the center in (2, 2).
In the second sample the signature is impossible to forge.
In the third sample Andrey can paint the borders of the squares with the centers in (2, 2) and (3, 2):
1. we have a clear paper:
...
...
...
...
2. use the pen with center at (2, 2).
###
#.#
###
...
3. use the pen with center at (3, 2).
###
###
###
###
In the fourth sample Andrey can paint the borders of the squares with the centers in (3, 3) and (3, 5).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long a[1002][1002] = {0};
long long n, m;
long long ck(long long i, long long j) {
if (i <= 1 || i >= n || j <= 1 || j >= m) return 0;
if (a[i][j - 1] && a[i][j + 1] && a[i + 1][j + 1] && a[i - 1][j - 1] &&
a[i + 1][j] && a[i - 1][j] && a[i - 1][j + 1] && a[i + 1][j - 1])
return 1;
else
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long i = 0, j, k = 0, l = 0, r = 0;
cin >> n >> m;
char c;
for (i = (1); i <= (n); i++) {
for (j = (1); j <= (m); j++) {
cin >> c;
if (c == '#')
a[i][j] = 1;
else
a[i][j] = 0;
}
}
for (i = (1); i <= (n); i++) {
for (j = (1); j <= (m); j++) {
if (a[i][j]) {
if (((ck(i - 1, j - 1) || ck(i - 1, j) || ck(i - 1, j + 1) ||
ck(i, j - 1) || ck(i, j + 1) || ck(i + 1, j - 1) ||
ck(i + 1, j + 1) || ck(i + 1, j))))
continue;
else {
cout << "NO\n";
return 0;
};
}
}
}
{
cout << "YES\n";
return 0;
};
}
``` |
### Prompt
Generate a CPP solution to the following problem:
Little C loves number Β«3Β» very much. He loves all things about it.
Now he is playing a game on a chessboard of size n Γ m. The cell in the x-th row and in the y-th column is called (x,y). Initially, The chessboard is empty. Each time, he places two chessmen on two different empty cells, the Manhattan distance between which is exactly 3. The Manhattan distance between two cells (x_i,y_i) and (x_j,y_j) is defined as |x_i-x_j|+|y_i-y_j|.
He want to place as many chessmen as possible on the chessboard. Please help him find the maximum number of chessmen he can place.
Input
A single line contains two integers n and m (1 β€ n,m β€ 10^9) β the number of rows and the number of columns of the chessboard.
Output
Print one integer β the maximum number of chessmen Little C can place.
Examples
Input
2 2
Output
0
Input
3 3
Output
8
Note
In the first example, the Manhattan distance between any two cells is smaller than 3, so the answer is 0.
In the second example, a possible solution is (1,1)(3,2), (1,2)(3,3), (2,1)(1,3), (3,1)(2,3).
### Response
```cpp
#include <bits/stdc++.h>
namespace xxx {
using namespace std;
const double EPS = 1e-8;
const double PI = acos(-1.0);
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
inline long long rd() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
long long pow_mod(long long a, long long n) {
if (n == 0) return 1;
long long x = pow_mod(a, n / 2);
long long ans = x * x % MOD;
if (n & 1) ans = ans * a % MOD;
return ans;
}
} // namespace xxx
using namespace xxx;
const int N = 1.5e7 + 10;
const int M = 3e5 + 20;
long long n, m;
int main() {
cin >> n >> m;
if (n > m) swap(n, m);
if (n == 1) {
long long ans = m / 6 * 6;
m %= 6;
if (m) {
if (m == 4)
ans += 2;
else if (m == 5)
ans += 4;
}
cout << ans << endl;
} else if (n == 2) {
if (m == 2)
cout << 0 << endl;
else if (m == 3)
cout << 4 << endl;
else if (m == 7)
cout << 12 << endl;
else
cout << n * m << endl;
} else {
if ((n & 1) && (m & 1))
cout << n * m - 1 << endl;
else
cout << n * m << endl;
}
exit(0);
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
You are given integer n. You have to arrange numbers from 1 to 2n, using each of them exactly once, on the circle, so that the following condition would be satisfied:
For every n consecutive numbers on the circle write their sum on the blackboard. Then any two of written on the blackboard 2n numbers differ not more than by 1.
For example, choose n = 3. On the left you can see an example of a valid arrangement: 1 + 4 + 5 = 10, 4 + 5 + 2 = 11, 5 + 2 + 3 = 10, 2 + 3 + 6 = 11, 3 + 6 + 1 = 10, 6 + 1 + 4 = 11, any two numbers differ by at most 1. On the right you can see an invalid arrangement: for example, 5 + 1 + 6 = 12, and 3 + 2 + 4 = 9, 9 and 12 differ more than by 1.
<image>
Input
The first and the only line contain one integer n (1 β€ n β€ 10^5).
Output
If there is no solution, output "NO" in the first line.
If there is a solution, output "YES" in the first line. In the second line output 2n numbers β numbers from 1 to 2n in the order they will stay in the circle. Each number should appear only once. If there are several solutions, you can output any of them.
Examples
Input
3
Output
YES
1 4 5 2 3 6
Input
4
Output
NO
Note
Example from the statement is shown for the first example.
It can be proved that there is no solution in the second example.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void Main();
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
while (~cin.peek()) Main(), cin.get();
return 0;
}
void Main() {
int n;
cin >> n;
if (n % 2 == 0) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
vector<int> a(n * 2);
int pos = 0;
for (int i = 1; i <= n * 2; i++) {
a[pos] = i;
if (i & 1)
pos = (pos + n) % (n * 2);
else
pos = (pos + 1) % (n * 2);
}
for (int i = 0; i < n * 2; i++) {
cout << a[i] << " \n"[i == n * 2 - 1];
}
}
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
Masha has three sticks of length a, b and c centimeters respectively. In one minute Masha can pick one arbitrary stick and increase its length by one centimeter. She is not allowed to break sticks.
What is the minimum number of minutes she needs to spend increasing the stick's length in order to be able to assemble a triangle of positive area. Sticks should be used as triangle's sides (one stick for one side) and their endpoints should be located at triangle's vertices.
Input
The only line contains tree integers a, b and c (1 β€ a, b, c β€ 100) β the lengths of sticks Masha possesses.
Output
Print a single integer β the minimum number of minutes that Masha needs to spend in order to be able to make the triangle of positive area from her sticks.
Examples
Input
3 4 5
Output
0
Input
2 5 3
Output
1
Input
100 10 10
Output
81
Note
In the first example, Masha can make a triangle from the sticks without increasing the length of any of them.
In the second example, Masha can't make a triangle of positive area from the sticks she has at the beginning, but she can spend one minute to increase the length 2 centimeter stick by one and after that form a triangle with sides 3, 3 and 5 centimeters.
In the third example, Masha can take 33 minutes to increase one of the 10 centimeters sticks by 33 centimeters, and after that take 48 minutes to increase another 10 centimeters stick by 48 centimeters. This way she can form a triangle with lengths 43, 58 and 100 centimeters in 81 minutes. One can show that it is impossible to get a valid triangle faster.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
vector<int> v(3);
cin >> v[0] >> v[1] >> v[2];
sort(v.begin(), v.end());
int ans = max(0, v[2] - v[1] - v[0] + 1);
cout << ans << endl;
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
Snuke is making sugar water in a beaker. Initially, the beaker is empty. Snuke can perform the following four types of operations any number of times. He may choose not to perform some types of operations.
* Operation 1: Pour 100A grams of water into the beaker.
* Operation 2: Pour 100B grams of water into the beaker.
* Operation 3: Put C grams of sugar into the beaker.
* Operation 4: Put D grams of sugar into the beaker.
In our experimental environment, E grams of sugar can dissolve into 100 grams of water.
Snuke will make sugar water with the highest possible density.
The beaker can contain at most F grams of substances (water and sugar combined), and there must not be any undissolved sugar in the beaker. Find the mass of the sugar water Snuke will make, and the mass of sugar dissolved in it. If there is more than one candidate, any of them will be accepted.
We remind you that the sugar water that contains a grams of water and b grams of sugar is \frac{100b}{a + b} percent. Also, in this problem, pure water that does not contain any sugar is regarded as 0 percent density sugar water.
Constraints
* 1 \leq A < B \leq 30
* 1 \leq C < D \leq 30
* 1 \leq E \leq 100
* 100A \leq F \leq 3 000
* A, B, C, D, E and F are all integers.
Inputs
Input is given from Standard Input in the following format:
A B C D E F
Outputs
Print two integers separated by a space. The first integer should be the mass of the desired sugar water, and the second should be the mass of the sugar dissolved in it.
Examples
Input
1 2 10 20 15 200
Output
110 10
Input
1 2 1 2 100 1000
Output
200 100
Input
17 19 22 26 55 2802
Output
2634 934
### Response
```cpp
#include <iostream>
using namespace std;
using ll = long long;
using ld = long double;
int main() {
int A, B, C, D, E, F, maxW{}, maxS{};
double m{};
cin >> A >> B >> C >> D >> E >> F;
for (int a = 0; a < F; a += 100*A) {
for (int b = 0; a + b < F; b += 100*B) {
for (int c = 0; a + b + c <= F; c += C) {
if (100.*c/(a+b+c) > E) break;
for (int d = 0; a + b + c + d <= F; d += D) {
auto co = 100.*(c+d)/(a+b+c+d);
if (co > m) {
if (c+d > (a+b)/100*E) break;
m = co;
maxW = a+b+c+d;
maxS = c+d;
}
}
}
}
}
if (!maxW) maxW = 100*A;
cout << maxW << " " << maxS << endl;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
During their New Year holidays, Alice and Bob play the following game using an array a of n integers:
* Players take turns, Alice moves first.
* Each turn a player chooses any element and removes it from the array.
* If Alice chooses even value, then she adds it to her score. If the chosen value is odd, Alice's score does not change.
* Similarly, if Bob chooses odd value, then he adds it to his score. If the chosen value is even, then Bob's score does not change.
If there are no numbers left in the array, then the game ends. The player with the highest score wins. If the scores of the players are equal, then a draw is declared.
For example, if n = 4 and a = [5, 2, 7, 3], then the game could go as follows (there are other options):
* On the first move, Alice chooses 2 and get two points. Her score is now 2. The array a is now [5, 7, 3].
* On the second move, Bob chooses 5 and get five points. His score is now 5. The array a is now [7, 3].
* On the third move, Alice chooses 7 and get no points. Her score is now 2. The array a is now [3].
* On the last move, Bob chooses 3 and get three points. His score is now 8. The array a is empty now.
* Since Bob has more points at the end of the game, he is the winner.
You want to find out who will win if both players play optimally. Note that there may be duplicate numbers in the array.
Input
The first line contains an integer t (1 β€ t β€ 10^4) β the number of test cases. Then t test cases follow.
The first line of each test case contains an integer n (1 β€ n β€ 2 β
10^5) β the number of elements in the array a.
The next line contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9) β the array a used to play the game.
It is guaranteed that the sum of n over all test cases does not exceed 2 β
10^5.
Output
For each test case, output on a separate line:
* "Alice" if Alice wins with the optimal play;
* "Bob" if Bob wins with the optimal play;
* "Tie", if a tie is declared during the optimal play.
Example
Input
4
4
5 2 7 3
3
3 2 1
4
2 2 2 2
2
7 8
Output
Bob
Tie
Alice
Alice
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
typedef vector <int> vi;
typedef pair <int, int> pii;
typedef vector <long long> vll;
typedef pair <long long, long long> pll;
#define pb push_back
#define all(c) c.begin(), c.end()
#define For(i, a, b) for (long long i = a; i < b; ++i)
#define Forr(i, a, b) for (long long i = a; i > b; --i)
#define um unordered_map
#define F first
#define S second
#define ll long long
#define endl "\n"
#define min(a,b) (a < b ? a : b)
#define max(a,b) (a > b ? a : b)
#define fast_io() ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1> void __f(const char* name, Arg1&& arg1) {cout << name << " : " << arg1 << endl;}
template <typename Arg1, typename... Args> void __f(const char* names, Arg1&& arg1, Args&&... args) {const char* comma = strchr(names + 1, ',');cout.write(names, comma - names) << " : " << arg1<<" | ";__f(comma+1, args...);}
/*----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
void solve() {
int n; cin >> n;
vll A, B;
For(i,0,n) {
ll a; cin >> a;
if (a&1) {
B.pb(a);
}
else {
A.pb(a);
}
}
n = A.size(); int m = B.size();
int ptr1 = n-1, ptr2 = m-1;
ll ans1 = 0, ans2 = 0;
sort(all(A)); sort(all(B));
bool turn = 0;
while (ptr1 >= 0 or ptr2 >= 0) {
if (ptr1 >= 0 and ptr2 >= 0) {
if (turn) {
if (A[ptr1] > B[ptr2]) {
--ptr1;
}
else {
ans2 += B[ptr2];
--ptr2;
}
}
else {
if (B[ptr2] > A[ptr1]) {
--ptr2;
}
else {
ans1 += A[ptr1];
--ptr1;
}
}
turn = !turn;
continue;
}
if (turn) {
if (ptr1 >= 0) {
--ptr1;
}
else {
ans2 += B[ptr2];
--ptr2;
}
}
else {
if (ptr2 >= 0) {
--ptr2;
}
else {
ans1 += A[ptr1];
--ptr1;
}
}
turn = !turn;
}
if (ans1 == ans2) {
cout << "Tie" << endl;
return;
}
if (ans1 > ans2) {
cout << "Alice" << endl;
return;
}
cout << "Bob" << endl;
}
int main() {
fast_io();
int t = 1;
cin >> t;
while (t--) solve();
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
Tyndex is again well ahead of the rivals! The reaction to the release of Zoozle Chrome browser was the release of a new browser Tyndex.Brome!
The popularity of the new browser is growing daily. And the secret is not even the Tyndex.Bar installed (the Tyndex.Bar automatically fills the glass with the finest 1664 cognac after you buy Tyndex.Bottles and insert in into a USB port). It is highly popular due to the well-thought interaction with the user.
Let us take, for example, the system of automatic address correction. Have you entered codehorses instead of codeforces? The gloomy Zoozle Chrome will sadly say that the address does not exist. Tyndex.Brome at the same time will automatically find the closest address and sent you there. That's brilliant!
How does this splendid function work? That's simple! For each potential address a function of the F error is calculated by the following rules:
* for every letter ci from the potential address c the closest position j of the letter ci in the address (s) entered by the user is found. The absolute difference |i - j| of these positions is added to F. So for every i (1 β€ i β€ |c|) the position j is chosen such, that ci = sj, and |i - j| is minimal possible.
* if no such letter ci exists in the address entered by the user, then the length of the potential address |c| is added to F.
After the values of the error function have been calculated for all the potential addresses the most suitable one is found.
To understand the special features of the above described method better, it is recommended to realize the algorithm of calculating the F function for an address given by the user and some set of potential addresses. Good luck!
Input
The first line contains two integers n and k (1 β€ n β€ 105, 1 β€ k β€ 105). They are the number of potential addresses and the length of the address entered by the user. The next line contains k lowercase Latin letters. They are the address entered by the user (s). Each next i-th (1 β€ i β€ n) line contains a non-empty sequence of lowercase Latin letters. They are the potential address. It is guaranteed that the total length of all the lines does not exceed 2Β·105.
Output
On each n line of the output file print a single number: the value of the error function when the current potential address is chosen.
Please, do not use %lld specificator to read or write 64-bit integers in C++. It is preffered to use cout (also you may use %I64d).
Examples
Input
2 10
codeforces
codeforces
codehorses
Output
0
12
Input
9 9
vkontakte
vcontacte
vkontrakte
vkollapse
vkrokodile
vtopke
vkapuste
vpechke
vk
vcodeforcese
Output
18
14
36
47
14
29
30
0
84
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int m, n, i, j, k;
int L[26][100000], R[26][100000];
string s, t;
int main() {
cin >> n >> m;
cin >> t;
for (i = 0; i < m; i++) {
for (j = 0; j < 26; j++) {
if (j != t[i] - 'a') {
if (i == 0)
L[j][i] = -1000000;
else
L[j][i] = L[j][i - 1];
} else
L[j][i] = i;
}
}
for (i = m - 1; i >= 0; i--) {
for (j = 0; j < 26; j++) {
if (j != t[i] - 'a') {
if (i == m - 1)
R[j][i] = 1000000;
else
R[j][i] = R[j][i + 1];
} else
R[j][i] = i;
}
}
for (i = 0; i < n; i++) {
cin >> s;
long long answer = 0, d;
for (j = 0; j < s.size(); j++) {
k = s[j] - 'a';
if (j >= m)
d = j - L[k][m - 1];
else
d = min(j - L[k][j], R[k][j] - j);
if (d >= 500000) d = s.size();
answer += d;
}
cout << answer << endl;
}
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
Takahashi has decided to hold fastest-finger-fast quiz games. Kizahashi, who is in charge of making the scoreboard, is struggling to write the program that manages the players' scores in a game, which proceeds as follows.
A game is played by N players, numbered 1 to N. At the beginning of a game, each player has K points.
When a player correctly answers a question, each of the other N-1 players receives minus one (-1) point. There is no other factor that affects the players' scores.
At the end of a game, the players with 0 points or lower are eliminated, and the remaining players survive.
In the last game, the players gave a total of Q correct answers, the i-th of which was given by Player A_i. For Kizahashi, write a program that determines whether each of the N players survived this game.
Constraints
* All values in input are integers.
* 2 \leq N \leq 10^5
* 1 \leq K \leq 10^9
* 1 \leq Q \leq 10^5
* 1 \leq A_i \leq N\ (1 \leq i \leq Q)
Input
Input is given from Standard Input in the following format:
N K Q
A_1
A_2
.
.
.
A_Q
Output
Print N lines. The i-th line should contain `Yes` if Player i survived the game, and `No` otherwise.
Examples
Input
6 3 4
3
1
3
2
Output
No
No
Yes
No
No
No
Input
6 5 4
3
1
3
2
Output
Yes
Yes
Yes
Yes
Yes
Yes
Input
10 13 15
3
1
4
1
5
9
2
6
5
3
5
8
9
7
9
Output
No
No
No
No
Yes
No
No
No
Yes
No
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int n,q,k;
int a[100005];
int c;
int main() {
cin>>n>>k>>q;
for(int i=1;i<=q;i++) {
scanf("%d",&c);
a[c]++;
}
for(int i=1;i<=n;i++)
if(a[i]+k>q) cout<<"Yes"<<endl;
else cout<<"No"<<endl;
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
We often go to supermarkets to buy some fruits or vegetables, and on the tag there prints the price for a kilo. But in some supermarkets, when asked how much the items are, the clerk will say that a yuan for b kilos (You don't need to care about what "yuan" is), the same as a/b yuan for a kilo.
Now imagine you'd like to buy m kilos of apples. You've asked n supermarkets and got the prices. Find the minimum cost for those apples.
You can assume that there are enough apples in all supermarkets.
Input
The first line contains two positive integers n and m (1 β€ n β€ 5 000, 1 β€ m β€ 100), denoting that there are n supermarkets and you want to buy m kilos of apples.
The following n lines describe the information of the supermarkets. Each line contains two positive integers a, b (1 β€ a, b β€ 100), denoting that in this supermarket, you are supposed to pay a yuan for b kilos of apples.
Output
The only line, denoting the minimum cost for m kilos of apples. Please make sure that the absolute or relative error between your answer and the correct answer won't exceed 10^{-6}.
Formally, let your answer be x, and the jury's answer be y. Your answer is considered correct if \frac{|x - y|}{max{(1, |y|)}} β€ 10^{-6}.
Examples
Input
3 5
1 2
3 4
1 3
Output
1.66666667
Input
2 1
99 100
98 99
Output
0.98989899
Note
In the first sample, you are supposed to buy 5 kilos of apples in supermarket 3. The cost is 5/3 yuan.
In the second sample, you are supposed to buy 1 kilo of apples in supermarket 2. The cost is 98/99 yuan.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long double n, m, a, b;
float x, ans = 1e18;
cin >> n >> m;
for (long long int i = 0; i < n; i++) {
cin >> a >> b;
x = (a * m) / b;
ans = min(x, ans);
}
cout << fixed << setprecision(8) << ans;
return 0;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
The annual college sports-ball tournament is approaching, which for trademark reasons we'll refer to as Third Month Insanity. There are a total of 2N teams participating in the tournament, numbered from 1 to 2N. The tournament lasts N rounds, with each round eliminating half the teams. The first round consists of 2N - 1 games, numbered starting from 1. In game i, team 2Β·i - 1 will play against team 2Β·i. The loser is eliminated and the winner advances to the next round (there are no ties). Each subsequent round has half as many games as the previous round, and in game i the winner of the previous round's game 2Β·i - 1 will play against the winner of the previous round's game 2Β·i.
Every year the office has a pool to see who can create the best bracket. A bracket is a set of winner predictions for every game. For games in the first round you may predict either team to win, but for games in later rounds the winner you predict must also be predicted as a winner in the previous round. Note that the bracket is fully constructed before any games are actually played. Correct predictions in the first round are worth 1 point, and correct predictions in each subsequent round are worth twice as many points as the previous, so correct predictions in the final game are worth 2N - 1 points.
For every pair of teams in the league, you have estimated the probability of each team winning if they play against each other. Now you want to construct a bracket with the maximum possible expected score.
Input
Input will begin with a line containing N (2 β€ N β€ 6).
2N lines follow, each with 2N integers. The j-th column of the i-th row indicates the percentage chance that team i will defeat team j, unless i = j, in which case the value will be 0. It is guaranteed that the i-th column of the j-th row plus the j-th column of the i-th row will add to exactly 100.
Output
Print the maximum possible expected score over all possible brackets. Your answer must be correct to within an absolute or relative error of 10 - 9.
Formally, let your answer be a, and the jury's answer be b. Your answer will be considered correct, if <image>.
Examples
Input
2
0 40 100 100
60 0 40 40
0 60 0 45
0 60 55 0
Output
1.75
Input
3
0 0 100 0 100 0 0 0
100 0 100 0 0 0 100 100
0 0 0 100 100 0 0 0
100 100 0 0 0 0 100 100
0 100 0 100 0 0 100 0
100 100 100 100 100 0 0 0
100 0 100 0 0 100 0 0
100 0 100 0 100 100 100 0
Output
12
Input
2
0 21 41 26
79 0 97 33
59 3 0 91
74 67 9 0
Output
3.141592
Note
In the first example, you should predict teams 1 and 4 to win in round 1, and team 1 to win in round 2. Recall that the winner you predict in round 2 must also be predicted as a winner in round 1.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int a[65][65];
double dp[130][70][2], pat, mx[130];
bool maqurast(int x) {
while (x > 1) {
if (x % 2 == 1) return 0;
x /= 2;
}
return 1;
}
int main() {
int n;
cin >> n;
int ast = 1;
for (int i = 0; i < n; i++) ast *= 2;
for (int i = 1; i <= ast; i++) {
for (int j = 1; j <= ast; j++) {
cin >> a[i][j];
}
}
for (int i = ast; i < 2 * ast; i++) {
dp[i][i - ast + 1][0] = 1;
dp[i][i - ast + 1][1] = 0;
mx[i] = 0;
}
int hast = 1;
for (int i = ast - 1; i > 0; i--) {
int nax1 = 2 * i;
int nax2 = 2 * i + 1;
for (int j = 1; j <= ast; j++) {
for (int k = 1; k <= ast; k++) {
dp[i][j][0] += dp[nax1][j][0] * dp[nax2][k][0] * 1.0 * a[j][k] / 100;
dp[i][j][0] += dp[nax2][j][0] * dp[nax1][k][0] * 1.0 * a[j][k] / 100;
}
}
}
for (int i = ast - 1; i > 0; i--) {
int nax1 = 2 * i;
int nax2 = 2 * i + 1;
for (int j = 1; j <= ast; j++) {
dp[i][j][1] =
max(dp[i][j][1], dp[i][j][0] * hast + max(dp[nax1][j][1] + mx[nax2],
dp[nax2][j][1] + mx[nax1]));
mx[i] = max(mx[i], dp[i][j][1]);
}
if (maqurast(i)) hast *= 2;
}
for (int i = 1; i <= ast; i++) pat = max(pat, dp[1][i][1]);
printf("%.10lf\n", pat);
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
There are N blocks arranged in a row. Let us paint these blocks.
We will consider two ways to paint the blocks different if and only if there is a block painted in different colors in those two ways.
Find the number of ways to paint the blocks under the following conditions:
* For each block, use one of the M colors, Color 1 through Color M, to paint it. It is not mandatory to use all the colors.
* There may be at most K pairs of adjacent blocks that are painted in the same color.
Since the count may be enormous, print it modulo 998244353.
Constraints
* All values in input are integers.
* 1 \leq N, M \leq 2 \times 10^5
* 0 \leq K \leq N - 1
Input
Input is given from Standard Input in the following format:
N M K
Output
Print the answer.
Examples
Input
3 2 1
Output
6
Input
100 100 0
Output
73074801
Input
60522 114575 7559
Output
479519525
### Response
```cpp
#include<bits/stdc++.h>
#define int long long
#define for0(i, n) for(int i = 0; i < (n); i++)
#define puts(x) cout << x << "\n"
constexpr int mod = 998244353;
using namespace std;
int f1(int a, int p) {
if (p == 1)return a;
if (p % 2)return f1(a, p - 1) * a % mod;
else return f1(a * a % mod, p / 2) % mod;
}
signed main() {
int n, m, k, ans = 0; cin >> n >> m >> k;
int p1 = m, p2 = 1;
for0(i, n) {
if (n - i - 1 <= k)ans += p1 * p2 % mod;
ans %= mod;
p1 *= m - 1; p1 %= mod;
p2 *= n - 1 - i; p2 %= mod;
p2 *= f1(i + 1, mod - 2); p2 %= mod;
}
puts(ans);
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
You are given two strings a and b. You have to remove the minimum possible number of consecutive (standing one after another) characters from string b in such a way that it becomes a subsequence of string a. It can happen that you will not need to remove any characters at all, or maybe you will have to remove all of the characters from b and make it empty.
Subsequence of string s is any such string that can be obtained by erasing zero or more characters (not necessarily consecutive) from string s.
Input
The first line contains string a, and the second line β string b. Both of these strings are nonempty and consist of lowercase letters of English alphabet. The length of each string is no bigger than 105 characters.
Output
On the first line output a subsequence of string a, obtained from b by erasing the minimum number of consecutive characters.
If the answer consists of zero characters, output Β«-Β» (a minus sign).
Examples
Input
hi
bob
Output
-
Input
abca
accepted
Output
ac
Input
abacaba
abcdcba
Output
abcba
Note
In the first example strings a and b don't share any symbols, so the longest string that you can get is empty.
In the second example ac is a subsequence of a, and at the same time you can obtain it by erasing consecutive symbols cepted from string b.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
const long long maxc = 2e9 + 7;
string a, b;
int pre[maxn], suf[maxn];
int n, m;
void solve(string a, string b, int pre[]) {
vector<vector<int> > pos;
pos.assign(27, vector<int>());
int n = a.size(), m = b.size();
a = ' ' + a, b = ' ' + b;
fill(pre + 1, pre + m + 1, maxc);
for (int i = (1); i <= (n); ++i) pos[a[i] - 'a'].push_back(i);
for (int i = (1); i <= (m); ++i) {
if (pre[i - 1] == maxc) continue;
auto it = upper_bound((pos[b[i] - 'a']).begin(), (pos[b[i] - 'a']).end(),
pre[i - 1]);
if (it == pos[b[i] - 'a'].end()) continue;
pre[i] = *it;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> a >> b;
solve(a, b, pre);
reverse((a).begin(), (a).end());
reverse((b).begin(), (b).end());
solve(a, b, suf);
reverse((a).begin(), (a).end());
reverse((b).begin(), (b).end());
int n = a.size(), m = b.size();
a = ' ' + a, b = ' ' + b;
for (int i = (1); i <= (m / 2); ++i) swap(suf[i], suf[m - i + 1]);
int j = 1, ans = 0;
int L = 0, R = 0;
for (int i = (0); i <= (m); ++i) {
j = max(j, i + 1);
while (pre[i] + suf[j] > n && j <= m + 1) ++j;
if (j <= m + 1 && pre[i] + suf[j] <= n) {
if (ans < m - j + 1 + i) {
ans = m - j + 1 + i;
L = i, R = j;
}
}
}
if (ans == 0)
cout << "-";
else {
for (int i = (1); i <= (L); ++i) cout << b[i];
for (int i = (R); i <= (m); ++i) cout << b[i];
}
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Snuke received an integer sequence a of length 2N-1.
He arbitrarily permuted the elements in a, then used it to construct a new integer sequence b of length N, as follows:
* b_1 = the median of (a_1)
* b_2 = the median of (a_1, a_2, a_3)
* b_3 = the median of (a_1, a_2, a_3, a_4, a_5)
* :
* b_N = the median of (a_1, a_2, a_3, ..., a_{2N-1})
How many different sequences can be obtained as b? Find the count modulo 10^{9} + 7.
Constraints
* 1 β€ N β€ 50
* 1 β€ a_i β€ 2N-1
* a_i are integers.
Input
Input is given from Standard Input in the following format:
N
a_1 a_2 ... a_{2N-1}
Output
Print the answer.
Examples
Input
2
1 3 2
Output
3
Input
4
1 3 2 3 2 4 3
Output
16
Input
15
1 5 9 11 1 19 17 18 20 1 14 3 3 8 19 15 16 29 10 2 4 13 6 12 7 15 16 1 1
Output
911828634
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int, int> P;
template<typename T> inline void chkmin(T &a, const T &b) { a = a < b ? a : b; }
template<typename T> inline void chkmax(T &a, const T &b) { a = a > b ? a : b; }
const int MAXN = 105, MOD = 1e9 + 7;
int f[MAXN][MAXN][MAXN], a[MAXN], n;
void add(int &x, int a) { x += a - MOD, x += x >> 31 & MOD; }
int main() {
scanf("%d", &n);
for (int i = 1; i < n * 2; i++) scanf("%d", a + i);
sort(a + 1, a + n * 2);
f[n][1][0] = 1;
for (int i = n; i > 1; i--) {
int al = a[i] != a[i - 1], ar = a[n * 2 - i] != a[n * 2 - i + 1];
for (int j = 1; j <= 2 * (n - i) + 1; j++)
for (int k = 0; k <= 2 * (n - i); k++) if (f[i][j][k]) {
int cur = f[i][j][k];
for (int l = 0; l < j + al; l++)
add(f[i - 1][j - l + al][ar + k + (l > 0)], cur);
for (int l = 0; l < k + ar; l++)
add(f[i - 1][j + al + 1][k - l + ar - 1], cur);
}
}
int res = 0;
for (int i = 0; i < 2 * n; i++)
for (int j = 0; j < 2 * n; j++) add(res, f[1][i][j]);
printf("%d\n", res);
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Polycarpus has a computer with n processors. Also, his computer has n memory cells. We'll consider the processors numbered by integers from 1 to n and that the memory cells are consecutively numbered by integers from 1 to n.
Polycarpus needs to come up with a parallel program model. For each memory cell number i this program must record the value n - i to this cell. In other words, for each cell you've got to find the distance to cell n.
Let's denote the value that is written in the i-th cell as ai. Initially, ai = 1 (1 β€ i < n) and an = 0. We will consider that only processor i can write values in the memory cell number i. All processors can read an information from some cell (several processors can read an information from some cell simultaneously).
The parallel program is executed in several steps. During each step we execute the parallel version of the increment operation. Executing the parallel version of the increment operation goes as follows:
1. Each processor independently of the other ones chooses some memory cell. Let's say that processor i has chosen a cell with number ci (1 β€ ci β€ n).
2. All processors simultaneously execute operation ai = ai + aci.
Help Polycarpus come up with the parallel program model that is executed in exactly k steps. Calculate the operations that need to be executed. Note that after k steps for all i's value ai must be equal n - i.
Input
The first line contains two space-separated integers n and k (1 β€ n β€ 104, 1 β€ k β€ 20).
It is guaranteed that at the given n and k the required sequence of operations exists.
Output
Print exactly nΒ·k integers in k lines. In the first line print numbers c1, c2, ..., cn (1 β€ ci β€ n) for the first increment operation. In the second line print the numbers for the second increment operation. In the k-th line print the numbers for the k-th increment operation.
As a result of the printed operations for any i value ai must equal n - i.
Examples
Input
1 1
Output
1
Input
3 2
Output
2 3 3
3 3 3
### Response
```cpp
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:67108864")
using namespace std;
int n, k, i, j, a[10005], b[10005], tmp[10005];
int BinSearch(int val) {
int l = 1, r = n, t = 0;
while (r - l > 1) {
t = (l + r) >> 1;
if (a[t] >= val)
l = t;
else
r = t;
}
return a[l] > val ? r : l;
}
int main() {
scanf("%d%d", &n, &k);
for (i = 1; i < n; ++i) a[i] = 1;
for (j = 1; j <= k; ++j) {
for (i = 1; i <= n; ++i) {
if (a[i] != n - i) {
int x = n - i - a[i];
int t = BinSearch(x);
b[i] = t;
} else
b[i] = n;
tmp[i] = a[i];
}
for (i = 1; i < n; ++i) {
a[i] += tmp[b[i]];
printf("%d ", b[i]);
}
a[i] += tmp[b[i]];
printf("%d\n", b[i]);
}
return 0;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
You want to perform the combo on your opponent in one popular fighting game. The combo is the string s consisting of n lowercase Latin letters. To perform the combo, you have to press all buttons in the order they appear in s. I.e. if s="abca" then you have to press 'a', then 'b', 'c' and 'a' again.
You know that you will spend m wrong tries to perform the combo and during the i-th try you will make a mistake right after p_i-th button (1 β€ p_i < n) (i.e. you will press first p_i buttons right and start performing the combo from the beginning). It is guaranteed that during the m+1-th try you press all buttons right and finally perform the combo.
I.e. if s="abca", m=2 and p = [1, 3] then the sequence of pressed buttons will be 'a' (here you're making a mistake and start performing the combo from the beginning), 'a', 'b', 'c', (here you're making a mistake and start performing the combo from the beginning), 'a' (note that at this point you will not perform the combo because of the mistake), 'b', 'c', 'a'.
Your task is to calculate for each button (letter) the number of times you'll press it.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 10^4) β the number of test cases.
Then t test cases follow.
The first line of each test case contains two integers n and m (2 β€ n β€ 2 β
10^5, 1 β€ m β€ 2 β
10^5) β the length of s and the number of tries correspondingly.
The second line of each test case contains the string s consisting of n lowercase Latin letters.
The third line of each test case contains m integers p_1, p_2, ..., p_m (1 β€ p_i < n) β the number of characters pressed right during the i-th try.
It is guaranteed that the sum of n and the sum of m both does not exceed 2 β
10^5 (β n β€ 2 β
10^5, β m β€ 2 β
10^5).
It is guaranteed that the answer for each letter does not exceed 2 β
10^9.
Output
For each test case, print the answer β 26 integers: the number of times you press the button 'a', the number of times you press the button 'b', ..., the number of times you press the button 'z'.
Example
Input
3
4 2
abca
1 3
10 5
codeforces
2 8 3 2 9
26 10
qwertyuioplkjhgfdsazxcvbnm
20 10 1 2 3 5 10 5 9 4
Output
4 2 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 9 4 5 3 0 0 0 0 0 0 0 0 9 0 0 3 1 0 0 0 0 0 0 0
2 1 1 2 9 2 2 2 5 2 2 2 1 1 5 4 11 8 2 7 5 1 10 1 5 2
Note
The first test case is described in the problem statement. Wrong tries are "a", "abc" and the final try is "abca". The number of times you press 'a' is 4, 'b' is 2 and 'c' is 2.
In the second test case, there are five wrong tries: "co", "codeforc", "cod", "co", "codeforce" and the final try is "codeforces". The number of times you press 'c' is 9, 'd' is 4, 'e' is 5, 'f' is 3, 'o' is 9, 'r' is 3 and 's' is 1.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << "{";
for (typename vector<T>::const_iterator vi = v.begin(); vi != v.end(); ++vi) {
if (vi != v.begin()) os << ", ";
os << *vi;
}
os << "}";
return os;
}
template <typename A, typename B>
ostream &operator<<(ostream &os, const pair<A, B> &p) {
os << '(' << p.first << ", " << p.second << ')';
return os;
}
void dbg_out() { cerr << endl; }
template <typename Head, typename... Tail>
void dbg_out(Head H, Tail... T) {
cerr << ' ' << H;
dbg_out(T...);
}
const long verybig = 10000000000000;
int gcd(int a, int b) {
if (a == 0) return b;
if (b == 0) return a;
if (a == b) return a;
if (a > b) return gcd(a - b, b);
return gcd(a, b - a);
}
bool isPrime(int n) {
if (n <= 1) return false;
for (int i = 2; i < n; i++)
if (n % i == 0) return false;
return true;
}
void solve() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
int a[k];
for (long long i = 0; i < (k); ++i) cin >> a[i];
int count[n];
memset(count, 0, sizeof(count));
for (int i = 0; i < k; i++) {
count[a[i] - 1]++;
}
for (int i = n - 1; i > 0; i--) count[i - 1] += count[i];
int c[26];
memset(c, 0, sizeof(c));
for (int i = 0; i < n; i++) {
c[s[i] - 97] += (count[i] + 1);
}
for (long long i = 0; i < (26); ++i) cout << c[i] << " ";
cout << "\n";
}
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cin.exceptions(cin.failbit);
long long t;
cin >> t;
for (long long i = 0; i < (t); ++i) solve();
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
On one of the planets of Solar system, in Atmosphere University, many students are fans of bingo game.
It is well known that one month on this planet consists of n^2 days, so calendars, represented as square matrix n by n are extremely popular.
Weather conditions are even more unusual. Due to the unique composition of the atmosphere, when interacting with sunlight, every day sky takes one of three colors: blue, green or red.
To play the bingo, you need to observe the sky for one month β after each day, its cell is painted with the color of the sky in that day, that is, blue, green or red.
At the end of the month, students examine the calendar. If at least one row or column contains only cells of one color, that month is called lucky.
Let's call two colorings of calendar different, if at least one cell has different colors in them. It is easy to see that there are 3^{n β
n} different colorings. How much of them are lucky? Since this number can be quite large, print it modulo 998244353.
Input
The first and only line of input contains a single integer n (1 β€ n β€ 1000 000) β the number of rows and columns in the calendar.
Output
Print one number β number of lucky colorings of the calendar modulo 998244353
Examples
Input
1
Output
3
Input
2
Output
63
Input
3
Output
9933
Note
In the first sample any coloring is lucky, since the only column contains cells of only one color.
In the second sample, there are a lot of lucky colorings, in particular, the following colorings are lucky:
<image>
While these colorings are not lucky:
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long N = 1000000 + 9;
long long c[N];
long long n, ans;
inline long long fast(long long a, long long b = 998244353ll - 2ll,
long long mod = 998244353ll) {
a %= 998244353ll;
b %= 998244353ll - 1;
long long res = 1ll;
while (b) {
if (b & 1ll) res = (res * a) % mod;
b >>= 1ll;
a = (a * a) % mod;
}
return res;
}
inline long long multi(long long a, long long b) {
a %= 998244353ll, b %= 998244353ll;
return (a * b) % 998244353ll;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
c[0] = 1ll;
for (long long i = 1ll; i <= n; i++) {
c[i] = c[i - 1];
c[i] = multi(c[i], n - i + 1);
c[i] = multi(c[i], fast(i));
}
for (long long i = 1ll; i <= n; i++) {
long long res = c[i];
res = multi(res, fast(3ll, n * (n - i)));
res = multi(res, fast(3ll, i));
if ((i + 1ll) % 2ll == 0ll)
ans += res;
else
ans -= res;
ans %= 998244353ll;
}
ans *= 2ll;
ans %= 998244353ll;
for (long long i = 0ll; i <= n - 1ll; i++) {
long long res = c[i];
res = multi(fast(1ll - fast(3ll, i), n) - fast(-fast(3ll, i), n), res);
res = multi(res, 3ll);
if ((i + 1ll) % 2ll == 0ll)
ans += res;
else
ans -= res;
ans %= 998244353ll;
}
ans %= 998244353ll;
ans += 998244353ll;
ans %= 998244353ll;
cout << ans;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
Vasya has recently developed a new algorithm to optimize the reception of customer flow and he considered the following problem.
Let the queue to the cashier contain n people, at that each of them is characterized by a positive integer ai β that is the time needed to work with this customer. What is special about this very cashier is that it can serve two customers simultaneously. However, if two customers need ai and aj of time to be served, the time needed to work with both of them customers is equal to max(ai, aj). Please note that working with customers is an uninterruptable process, and therefore, if two people simultaneously come to the cashier, it means that they begin to be served simultaneously, and will both finish simultaneously (it is possible that one of them will have to wait).
Vasya used in his algorithm an ingenious heuristic β as long as the queue has more than one person waiting, then some two people of the first three standing in front of the queue are sent simultaneously. If the queue has only one customer number i, then he goes to the cashier, and is served within ai of time. Note that the total number of phases of serving a customer will always be equal to βn / 2β.
Vasya thinks that this method will help to cope with the queues we all hate. That's why he asked you to work out a program that will determine the minimum time during which the whole queue will be served using this algorithm.
Input
The first line of the input file contains a single number n (1 β€ n β€ 1000), which is the number of people in the sequence. The second line contains space-separated integers a1, a2, ..., an (1 β€ ai β€ 106). The people are numbered starting from the cashier to the end of the queue.
Output
Print on the first line a single number β the minimum time needed to process all n people. Then on βn / 2β lines print the order in which customers will be served. Each line (probably, except for the last one) must contain two numbers separated by a space β the numbers of customers who will be served at the current stage of processing. If n is odd, then the last line must contain a single number β the number of the last served customer in the queue. The customers are numbered starting from 1.
Examples
Input
4
1 2 3 4
Output
6
1 2
3 4
Input
5
2 4 3 1 4
Output
8
1 3
2 5
4
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int F[1005][1005], a[1005], n;
int call(int i, int j) {
int &ret = F[i][j];
if (ret != -1) return ret;
if (j == n)
return ret = a[i];
else if (j == n - 1)
return ret = max(a[i], a[j]);
return ret = min(max(a[j], a[j + 1]) + call(i, j + 2),
min(max(a[i], a[j]) + call(j + 1, j + 2),
max(a[i], a[j + 1]) + call(j, j + 2)));
}
void backtrack(int i, int j) {
if (j == n) {
cout << i + 1 << "\n";
} else if (j == n - 1) {
cout << i + 1 << " " << j + 1 << "\n";
} else {
if (F[i][j] == max(a[j], a[j + 1]) + F[i][j + 2]) {
cout << j + 1 << " " << j + 2 << "\n";
backtrack(i, j + 2);
} else if (F[i][j] == max(a[i], a[j]) + F[j + 1][j + 2]) {
cout << i + 1 << " " << j + 1 << "\n";
backtrack(j + 1, j + 2);
} else {
cout << i + 1 << " " << j + 2 << "\n";
backtrack(j, j + 2);
}
}
return;
}
int main() {
cin >> n;
memset(F, -1, sizeof(F));
for (int i = 0; i < n; i++) cin >> a[i];
cout << call(0, 1) << "\n";
backtrack(0, 1);
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Heidi's friend Jenny is asking Heidi to deliver an important letter to one of their common friends. Since Jenny is Irish, Heidi thinks that this might be a prank. More precisely, she suspects that the message she is asked to deliver states: "Send the fool further!", and upon reading it the recipient will ask Heidi to deliver the same message to yet another friend (that the recipient has in common with Heidi), and so on.
Heidi believes that her friends want to avoid awkward situations, so she will not be made to visit the same person (including Jenny) twice. She also knows how much it costs to travel between any two of her friends who know each other. She wants to know: what is the maximal amount of money she will waste on travel if it really is a prank?
Heidi's n friends are labeled 0 through n - 1, and their network of connections forms a tree. In other words, every two of her friends a, b know each other, possibly indirectly (there is a sequence of friends starting from a and ending on b and such that each two consecutive friends in the sequence know each other directly), and there are exactly n - 1 pairs of friends who know each other directly.
Jenny is given the number 0.
Input
The first line of the input contains the number of friends n (3 β€ n β€ 100). The next n - 1 lines each contain three space-separated integers u, v and c (0 β€ u, v β€ n - 1, 1 β€ c β€ 104), meaning that u and v are friends (know each other directly) and the cost for travelling between u and v is c.
It is guaranteed that the social network of the input forms a tree.
Output
Output a single integer β the maximum sum of costs.
Examples
Input
4
0 1 4
0 2 2
2 3 3
Output
5
Input
6
1 2 3
0 2 100
1 4 2
0 3 7
3 5 10
Output
105
Input
11
1 0 1664
2 0 881
3 2 4670
4 2 1555
5 1 1870
6 2 1265
7 2 288
8 7 2266
9 2 1536
10 6 3378
Output
5551
Note
In the second example, the worst-case scenario goes like this: Jenny sends Heidi to the friend labeled by number 2 (incurring a cost of 100), then friend 2 sends her to friend 1 (costing Heidi 3), and finally friend 1 relays her to friend 4 (incurring an additional cost of 2).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int max1 = 3e4 + 5;
vector<pair<int, int>> adj[max1];
int n, ans = 0;
bool vis[max1] = {false};
void dfs(int n, int val) {
if (vis[n]) {
return;
}
int temp = val;
ans = max(ans, temp);
vis[n] = true;
for (auto x : adj[n]) {
dfs(x.first, temp + x.second);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long t = 1;
while (t--) {
cin >> n;
for (int i = 0; i < n - 1; i++) {
int t1, t2, len;
cin >> t1 >> t2 >> len;
adj[t1].push_back({t2, len});
adj[t2].push_back({t1, len});
}
dfs(0, 0);
cout << ans;
}
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
A wise king declared a new calendar. "Tomorrow shall be the first day of the calendar, that is, the day 1 of the month 1 of the year 1. Each year consists of 10 months, from month 1 through month 10, and starts from a big month. A common year shall start with a big month, followed by small months and big months one after another. Therefore the first month is a big month, the second month is a small month, the third a big month, ..., and the 10th and last month a small one. A big month consists of 20 days and a small month consists of 19 days. However years which are multiples of three, that are year 3, year 6, year 9, and so on, shall consist of 10 big months and no small month."
Many years have passed since the calendar started to be used. For celebration of the millennium day (the year 1000, month 1, day 1), a royal lottery is going to be organized to send gifts to those who have lived as many days as the number chosen by the lottery. Write a program that helps people calculate the number of days since their birthdate to the millennium day.
Input
The input is formatted as follows.
> n
> Y1 M1 D1
> Y2 M2 D2
> ...
> Yn Mn Dn
Here, the first line gives the number of datasets as a positive integer n, which is less than or equal to 100. It is followed by n datasets. Each dataset is formatted in a line and gives three positive integers, Yi (< 1000), Mi (β€ 10), and Di (β€ 20), that correspond to the year, month and day, respectively, of a person's birthdate in the king's calendar. These three numbers are separated by a space.
Output
For the birthdate specified in each dataset, print in a line the number of days from the birthdate, inclusive, to the millennium day, exclusive. Output lines should not contain any character other than this number.
Sample Input
8
1 1 1
344 3 1
696 5 1
182 9 5
998 8 7
344 2 19
696 4 19
999 10 20
Output for the Sample Input
196470
128976
59710
160715
252
128977
59712
1
Example
Input
8
1 1 1
344 3 1
696 5 1
182 9 5
998 8 7
344 2 19
696 4 19
999 10 20
Output
196470
128976
59710
160715
252
128977
59712
1
### Response
```cpp
#include <iostream>
using namespace std;
int main(void)
{
int yeardays[3]= {200, 195, 195};
int monthdays[2]= {0, 20};
int num;
cin>>num;
for(int i= 0; i < num; i++)
{
int year, month, day;
cin>>year>>month>>day;
long long int sum= 1;
for(int j= year; j < 1000; j++)
sum+= yeardays[j%3];
if(year % 3 == 0)
monthdays[0]= 20;
else
monthdays[0]= 19;
for(int j= 1; j < month; j++)
sum-= monthdays[j%2];
sum-= day;
cout<<sum<<endl;
}
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
Theseus has just arrived to Crete to fight Minotaur. He found a labyrinth that has a form of a rectangular field of size n Γ m and consists of blocks of size 1 Γ 1.
Each block of the labyrinth has a button that rotates all blocks 90 degrees clockwise. Each block rotates around its center and doesn't change its position in the labyrinth. Also, each block has some number of doors (possibly none). In one minute, Theseus can either push the button in order to rotate all the blocks 90 degrees clockwise or pass to the neighbouring block. Theseus can go from block A to some neighbouring block B only if block A has a door that leads to block B and block B has a door that leads to block A.
Theseus found an entrance to labyrinth and is now located in block (xT, yT) β the block in the row xT and column yT. Theseus know that the Minotaur is hiding in block (xM, yM) and wants to know the minimum number of minutes required to get there.
Theseus is a hero, not a programmer, so he asks you to help him.
Input
The first line of the input contains two integers n and m (1 β€ n, m β€ 1000) β the number of rows and the number of columns in labyrinth, respectively.
Each of the following n lines contains m characters, describing the blocks of the labyrinth. The possible characters are:
* Β«+Β» means this block has 4 doors (one door to each neighbouring block);
* Β«-Β» means this block has 2 doors β to the left and to the right neighbours;
* Β«|Β» means this block has 2 doors β to the top and to the bottom neighbours;
* Β«^Β» means this block has 1 door β to the top neighbour;
* Β«>Β» means this block has 1 door β to the right neighbour;
* Β«<Β» means this block has 1 door β to the left neighbour;
* Β«vΒ» means this block has 1 door β to the bottom neighbour;
* Β«LΒ» means this block has 3 doors β to all neighbours except left one;
* Β«RΒ» means this block has 3 doors β to all neighbours except right one;
* Β«UΒ» means this block has 3 doors β to all neighbours except top one;
* Β«DΒ» means this block has 3 doors β to all neighbours except bottom one;
* Β«*Β» means this block is a wall and has no doors.
Left, right, top and bottom are defined from representing labyrinth as a table, where rows are numbered from 1 to n from top to bottom and columns are numbered from 1 to m from left to right.
Next line contains two integers β coordinates of the block (xT, yT) (1 β€ xT β€ n, 1 β€ yT β€ m), where Theseus is initially located.
Last line contains two integers β coordinates of the block (xM, yM) (1 β€ xM β€ n, 1 β€ yM β€ m), where Minotaur hides.
It's guaranteed that both the block where Theseus starts and the block where Minotaur is hiding have at least one door. Theseus and Minotaur may be initially located at the same block.
Output
If Theseus is not able to get to Minotaur, then print -1 in the only line of the output. Otherwise, print the minimum number of minutes required to get to the block where Minotaur is hiding.
Examples
Input
2 2
+*
*U
1 1
2 2
Output
-1
Input
2 3
<><
><>
1 1
2 1
Output
4
Note
Assume that Theseus starts at the block (xT, yT) at the moment 0.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int dx[4] = {-1, +0, +1, +0};
const int dy[4] = {+0, +1, +0, -1};
vector<int> g[256];
vector<string> s(1000);
int dp[1000][1000][4], vis[1000][1000][4], n, m;
struct box {
int val, x, y, d;
bool operator<(const box& other) const { return val > other.val; }
};
int32_t main() {
g['+'] = {1, 1, 1, 1};
g['-'] = {0, 1, 0, 1};
g['|'] = {1, 0, 1, 0};
g['^'] = {1, 0, 0, 0};
g['>'] = {0, 1, 0, 0};
g['<'] = {0, 0, 0, 1};
g['v'] = {0, 0, 1, 0};
g['L'] = {1, 1, 1, 0};
g['R'] = {1, 0, 1, 1};
g['U'] = {0, 1, 1, 1};
g['D'] = {1, 1, 0, 1};
g['*'] = {0, 0, 0, 0};
for (int i = 0; i < 1000; ++i)
for (int j = 0; j < 1000; ++j)
for (int k = 0; k < 4; ++k) dp[i][j][k] = 1e9;
cin >> n >> m;
for (int i = 0; i < n; ++i) cin >> s[i];
int x[2], y[2];
for (int k = 0; k < 2; ++k) cin >> x[k] >> y[k], --x[k], --y[k];
priority_queue<box> pq;
dp[x[0]][y[0]][0] = 0;
pq.push({dp[x[0]][y[0]][0], x[0], y[0], 0});
while (pq.size()) {
box u = pq.top();
pq.pop();
if (vis[u.x][u.y][u.d]) continue;
vis[u.x][u.y][u.d] = 1;
for (int k = 0; k < 4; ++k) {
int x = u.x + dx[k], y = u.y + dy[k];
if (x >= 0 && x < n && y >= 0 && y < m) {
for (int r = 0; r < 4; ++r) {
int R = (u.d + r) % 4;
if (g[1 * s[u.x][u.y]][(k - R + 4) % 4] &&
g[1 * s[x][y]][(k - R + 2 + 4) % 4] &&
dp[x][y][R] > dp[u.x][u.y][u.d] + r + 1)
dp[x][y][R] = dp[u.x][u.y][u.d] + r + 1,
pq.push({dp[x][y][R], x, y, R});
}
}
}
}
int ans = 1e9;
for (int k = 0; k < 4; ++k) ans = min(ans, dp[x[1]][y[1]][k]);
cout << (ans < 1e9 ? ans : -1) << endl;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
In CODE FESTIVAL XXXX, there are N+1 participants from all over the world, including Takahashi.
Takahashi checked and found that the time gap (defined below) between the local times in his city and the i-th person's city was D_i hours. The time gap between two cities is defined as follows. For two cities A and B, if the local time in city B is d o'clock at the moment when the local time in city A is 0 o'clock, then the time gap between these two cities is defined to be min(d,24-d) hours. Here, we are using 24-hour notation. That is, the local time in the i-th person's city is either d o'clock or 24-d o'clock at the moment when the local time in Takahashi's city is 0 o'clock, for example.
Then, for each pair of two people chosen from the N+1 people, he wrote out the time gap between their cities. Let the smallest time gap among them be s hours.
Find the maximum possible value of s.
Constraints
* 1 \leq N \leq 50
* 0 \leq D_i \leq 12
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
D_1 D_2 ... D_N
Output
Print the maximum possible value of s.
Examples
Input
3
7 12 8
Output
4
Input
2
11 11
Output
2
Input
1
0
Output
0
### Response
```cpp
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int main(){
int n;
cin >> n;
vector<int> c(25);
c[0] = 1;
for(int i = 0; i < n; i++){
int x;
cin >> x;
c[x]++;
}
c[24] = c[0];
int p = 0;
for(int i = 1; i <= 11; i++){
if(c[i] >= 1){
c[24 - i] = (c[i] + 1 - p) / 2;
c[i] = (c[i] + p) / 2;
p = 1 - p;
}
}
int t = 1, ans = 24;
for(int i = 1; i <= 24; i++){
if(c[i] >= 2){
ans = 0;
break;
}else if(c[i] == 1){
ans = min(ans, t);
t = 1;
}else{
t++;
}
}
cout << ans << endl;
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
AtCoDeer the deer recently bought three paint cans. The color of the one he bought two days ago is a, the color of the one he bought yesterday is b, and the color of the one he bought today is c. Here, the color of each paint can is represented by an integer between 1 and 100, inclusive.
Since he is forgetful, he might have bought more than one paint can in the same color. Count the number of different kinds of colors of these paint cans and tell him.
Constraints
* 1β¦a,b,cβ¦100
Input
The input is given from Standard Input in the following format:
a b c
Output
Print the number of different kinds of colors of the paint cans.
Examples
Input
3 1 4
Output
3
Input
3 3 33
Output
2
### Response
```cpp
#include<iostream>
using namespace std;
int main(void){
int a,b,c,n(1);
cin>>a>>b>>c;
if(b!=a)n++;
if(c!=b && c!=a)n++;
cout<<n<<endl;
return 0;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
Let x be a string of length at least 1. We will call x a good string, if for any string y and any integer k (k \geq 2), the string obtained by concatenating k copies of y is different from x. For example, `a`, `bbc` and `cdcdc` are good strings, while `aa`, `bbbb` and `cdcdcd` are not.
Let w be a string of length at least 1. For a sequence F=(\,f_1,\,f_2,\,...,\,f_m) consisting of m elements, we will call F a good representation of w, if the following conditions are both satisfied:
* For any i \, (1 \leq i \leq m), f_i is a good string.
* The string obtained by concatenating f_1,\,f_2,\,...,\,f_m in this order, is w.
For example, when w=`aabb`, there are five good representations of w:
* (`aabb`)
* (`a`,`abb`)
* (`aab`,`b`)
* (`a`,`ab`,`b`)
* (`a`,`a`,`b`,`b`)
Among the good representations of w, the ones with the smallest number of elements are called the best representations of w. For example, there are only one best representation of w=`aabb`: (`aabb`).
You are given a string w. Find the following:
* the number of elements of a best representation of w
* the number of the best representations of w, modulo 1000000007 \, (=10^9+7)
(It is guaranteed that a good representation of w always exists.)
Constraints
* 1 \leq |w| \leq 500000 \, (=5 \times 10^5)
* w consists of lowercase letters (`a`-`z`).
Input
The input is given from Standard Input in the following format:
w
Output
Print 2 lines.
* In the first line, print the number of elements of a best representation of w.
* In the second line, print the number of the best representations of w, modulo 1000000007.
Examples
Input
aab
Output
1
1
Input
bcbc
Output
2
3
Input
ddd
Output
3
1
### Response
```cpp
#include<iostream>
#include<algorithm>
#define maxn 500005
using namespace std;
bool same(string s) {
char base = s[0];
for (char c : s)
if (c != base)
return false;
return true;
}
int f[2][maxn];
bool good[2][maxn];
void kmp(string s, int* f, bool* good) {
f[0] = -1;
for (int i = 1, j = -1; i < (int)s.size(); i++) {
while (j != -1 && s[i] != s[j + 1]) j = f[j];
if (s[i] == s[j + 1]) j++;
f[i] = j;
}
good[0] = true;
for (int i = 1; i < (int)s.size(); i++)
if (f[i] == -1 || (i + 1) % (i - f[i]) != 0)
good[i] = true;
}
int main() {
string s; cin >> s;
if (same(s)) {
cout << (int)s.size() << endl << 1 << endl;
}
else {
kmp(s, f[0], good[0]);
if (good[0][(int)s.size() - 1]) {
cout << 1 << endl << 1 << endl;
}
else {
reverse(s.begin(), s.end());
kmp(s, f[1], good[1]);
int ans = 0;
for (int i = 0; i < (int)s.size() - 1; i++)
if (good[0][i] && good[1][(int)s.size() - 1 - (i + 1)])
ans++;
cout << 2 << endl << ans << endl;
}
}
return 0;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
A few years ago Sajjad left his school and register to another one due to security reasons. Now he wishes to find Amir, one of his schoolmates and good friends.
There are n schools numerated from 1 to n. One can travel between each pair of them, to do so, he needs to buy a ticket. The ticker between schools i and j costs <image> and can be used multiple times. Help Sajjad to find the minimum cost he needs to pay for tickets to visit all schools. He can start and finish in any school.
Input
The first line contains a single integer n (1 β€ n β€ 105) β the number of schools.
Output
Print single integer: the minimum cost of tickets needed to visit all schools.
Examples
Input
2
Output
0
Input
10
Output
4
Note
In the first example we can buy a ticket between the schools that costs <image>.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, ans = 0;
cin >> n;
for (int i = 1, j = n; i < j;) {
if (i + 1 >= j) break;
ans++;
i++;
j--;
}
cout << ans;
return 0;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
You are given m sets of integers A_1, A_2, β¦, A_m; elements of these sets are integers between 1 and n, inclusive.
There are two arrays of positive integers a_1, a_2, β¦, a_m and b_1, b_2, β¦, b_n.
In one operation you can delete an element j from the set A_i and pay a_i + b_j coins for that.
You can make several (maybe none) operations (some sets can become empty).
After that, you will make an edge-colored undirected graph consisting of n vertices. For each set A_i you will add an edge (x, y) with color i for all x, y β A_i and x < y. Some pairs of vertices can be connected with more than one edge, but such edges have different colors.
You call a cycle i_1 β e_1 β i_2 β e_2 β β¦ β i_k β e_k β i_1 (e_j is some edge connecting vertices i_j and i_{j+1} in this graph) rainbow if all edges on it have different colors.
Find the minimum number of coins you should pay to get a graph without rainbow cycles.
Input
The first line contains two integers m and n (1 β€ m, n β€ 10^5), the number of sets and the number of vertices in the graph.
The second line contains m integers a_1, a_2, β¦, a_m (1 β€ a_i β€ 10^9).
The third line contains n integers b_1, b_2, β¦, b_n (1 β€ b_i β€ 10^9).
In the each of the next of m lines there are descriptions of sets. In the i-th line the first integer s_i (1 β€ s_i β€ n) is equal to the size of A_i. Then s_i integers follow: the elements of the set A_i. These integers are from 1 to n and distinct.
It is guaranteed that the sum of s_i for all 1 β€ i β€ m does not exceed 2 β
10^5.
Output
Print one integer: the minimum number of coins you should pay for operations to avoid rainbow cycles in the obtained graph.
Examples
Input
3 2
1 2 3
4 5
2 1 2
2 1 2
2 1 2
Output
11
Input
7 8
3 6 7 9 10 7 239
8 1 9 7 10 2 6 239
3 2 1 3
2 4 1
3 1 3 7
2 4 3
5 3 4 5 6 7
2 5 7
1 8
Output
66
Note
In the first test, you can make such operations:
* Delete element 1 from set 1. You should pay a_1 + b_1 = 5 coins for that.
* Delete element 1 from set 2. You should pay a_2 + b_1 = 6 coins for that.
You pay 11 coins in total. After these operations, the first and the second sets will be equal to \{2\} and the third set will be equal to \{1, 2\}.
So, the graph will consist of one edge (1, 2) of color 3.
In the second test, you can make such operations:
* Delete element 1 from set 1. You should pay a_1 + b_1 = 11 coins for that.
* Delete element 4 from set 2. You should pay a_2 + b_4 = 13 coins for that.
* Delete element 7 from set 3. You should pay a_3 + b_7 = 13 coins for that.
* Delete element 4 from set 4. You should pay a_4 + b_4 = 16 coins for that.
* Delete element 7 from set 6. You should pay a_6 + b_7 = 13 coins for that.
You pay 66 coins in total.
After these operations, the sets will be:
* \{2, 3\};
* \{1\};
* \{1, 3\};
* \{3\};
* \{3, 4, 5, 6, 7\};
* \{5\};
* \{8\}.
We will get the graph:
<image>
There are no rainbow cycles in it.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int fa[200001], a[100001], b[100001];
struct edge {
int u, v;
edge(int a, int b) : u(a), v(b) {}
};
bool operator<(const edge &x, const edge &y) {
return a[x.u] + b[x.v] > a[y.u] + b[y.v];
}
vector<edge> e;
int getfa(int x) {
if (!fa[x]) return x;
return fa[x] = getfa(fa[x]);
}
int main() {
int m, n;
cin >> m >> n;
for (int i = 1; i <= m; i++) cin >> a[i];
for (int j = 1; j <= n; j++) cin >> b[j];
for (int i = 1; i <= m; i++) {
int s;
cin >> s;
for (int j = 1; j <= s; j++) {
int x;
cin >> x;
e.push_back(edge(i, x));
}
}
sort(e.begin(), e.end());
long long ans = 0;
for (int i = 0; i < e.size(); i++) {
int u = e[i].u, v = e[i].v;
int p = getfa(u), q = getfa(v + m);
if (p == q) {
ans += a[u] + b[v];
continue;
}
fa[p] = q;
}
cout << ans << endl;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
In order to participate in the Asian Regional Qualifiers of the International Collegiate Programming Contest held every year in Japan, we must break through the strict domestic qualifiers.
Even though it is a university competition, multiple teams from one school will participate. Therefore, the following selection rules apply to the selection of breakthrough teams so that as many schools as possible can participate in the Asian Qualifiers:
Let A be the team and apply the following rules in order of best grade:
* Rule 1:
If the number of selected teams at that time is less than 10:
If the number of teams in the same affiliation as A and selected at that time is less than 3, A will be selected.
* Rule 2:
If the number of selected teams at that time is less than 20:
If the number of teams in the same affiliation as A and selected at that time is less than 2, A will be selected.
* Rule 3:
If the number of selected teams at that time is less than 26:
If there is no team in the same affiliation as A and selected at that time, A will be selected.
In addition, the order of grades is determined by the following rules:
* The team that solved more problems will be ranked higher.
* If the number of problems solved is the same, the team with the smaller penalty will be ranked higher.
Enter the ID (integer), affiliation (integer), number of correct answers (integer), and penalty (integer) of each team, and create a program that outputs the ID of the selected team in the order of selection. Please note that teams are not always given in order of grade, so selection rules must be applied after ranking.
In this question, if there is a team with the same number of correct answers and the same penalty, the one with the smaller ID will be ranked higher.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
n (number of teams: integer)
I1 U1 A1 P1 (ID of first team, affiliation, number of correct answers, penalty: 4 integers separated by blanks)
I2 U2 A2 P2 (ID of second team, affiliation, number of correct answers, penalty: 4 integers separated by blanks)
..
..
In Un An Pn (ID of nth team, affiliation, number of correct answers, penalty: 4 integers separated by blanks)
n is 300 or less, and Ii and Ui are 1 or more and 1000 or less. You can assume that there are no teams with the same ID in a dataset.
Ai should be 10 or less and Pi should be 100,000 or less.
When n is 0, it is the end of input.
Output
For each dataset, output the IDs of the selected teams in the order in which they were selected. Please output one ID on one line.
Example
Input
6
1 1 6 200
2 1 6 300
3 1 6 400
4 2 5 1200
5 1 5 1400
6 3 4 800
3
777 1 5 300
808 2 4 20
123 3 6 500
2
2 1 3 100
1 1 3 100
0
Output
1
2
3
4
6
123
777
808
1
2
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
typedef pair<int,int> P;
typedef pair<P,P> Pi;
int main(){
int n;
Pi team[333];
while(cin >> n,n){
for(int i=0;i<n;i++){
int I,U,A,B;
cin >> I >> U >> A >> B;
P tmp1; tmp1.first = A; tmp1.second = -B;
P tmp2; tmp2.first = -I; tmp2.second = U;
team[i].first = tmp1; team[i].second = tmp2;
}
sort(team,team+n,greater<Pi>() );
int idx = 0;
int cnt = 0;
int flg[1111]={0};
while(idx < n && cnt < 26){
int num = team[idx].second.second;
int ID = -team[idx].second.first;
if(cnt < 10){
if(flg[num] < 3){
flg[num]++;
cnt++;
cout << ID << endl;
}
} else if(cnt < 20){
if(flg[num] < 2){
flg[num]++;
cnt++;
cout << ID << endl;
}
} else if(cnt < 26){
if(flg[num] < 1){
flg[num]++;
cnt++;
cout << ID << endl;
}
}
idx++;
}
}
}
``` |
### Prompt
Create a solution in CPP for the following problem:
A new pack of n t-shirts came to a shop. Each of the t-shirts is characterized by three integers pi, ai and bi, where pi is the price of the i-th t-shirt, ai is front color of the i-th t-shirt and bi is back color of the i-th t-shirt. All values pi are distinct, and values ai and bi are integers from 1 to 3.
m buyers will come to the shop. Each of them wants to buy exactly one t-shirt. For the j-th buyer we know his favorite color cj.
A buyer agrees to buy a t-shirt, if at least one side (front or back) is painted in his favorite color. Among all t-shirts that have colors acceptable to this buyer he will choose the cheapest one. If there are no such t-shirts, the buyer won't buy anything. Assume that the buyers come one by one, and each buyer is served only after the previous one is served.
You are to compute the prices each buyer will pay for t-shirts.
Input
The first line contains single integer n (1 β€ n β€ 200 000) β the number of t-shirts.
The following line contains sequence of integers p1, p2, ..., pn (1 β€ pi β€ 1 000 000 000), where pi equals to the price of the i-th t-shirt.
The following line contains sequence of integers a1, a2, ..., an (1 β€ ai β€ 3), where ai equals to the front color of the i-th t-shirt.
The following line contains sequence of integers b1, b2, ..., bn (1 β€ bi β€ 3), where bi equals to the back color of the i-th t-shirt.
The next line contains single integer m (1 β€ m β€ 200 000) β the number of buyers.
The following line contains sequence c1, c2, ..., cm (1 β€ cj β€ 3), where cj equals to the favorite color of the j-th buyer. The buyers will come to the shop in the order they are given in the input. Each buyer is served only after the previous one is served.
Output
Print to the first line m integers β the j-th integer should be equal to the price of the t-shirt which the j-th buyer will buy. If the j-th buyer won't buy anything, print -1.
Examples
Input
5
300 200 400 500 911
1 2 1 2 3
2 1 3 2 1
6
2 3 1 2 1 1
Output
200 400 300 500 911 -1
Input
2
1000000000 1
1 1
1 2
2
2 1
Output
1 1000000000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 2e5 + 1, INF = 1e17, MOD = 1e9 + 7;
int n, m, a[MAXN], b[MAXN];
long long c[MAXN];
set<pair<long long, int> > s[4];
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 0; i < n; ++i) cin >> c[i];
for (int i = 0; i < n; ++i) {
cin >> a[i];
s[a[i]].insert(pair<long long, int>(c[i], i));
}
for (int i = 0; i < n; ++i) {
cin >> b[i];
s[b[i]].insert(pair<long long, int>(c[i], i));
}
cin >> m;
for (int i = 0; i < m; ++i) {
long long q;
cin >> q;
if (s[q].size() == 0) {
cout << -1 << endl;
continue;
}
pair<long long, int> p = *s[q].begin();
s[b[p.second]].erase(p);
s[a[p.second]].erase(p);
cout << p.first << endl;
}
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
You are given two multisets A and B. Each multiset has exactly n integers each between 1 and n inclusive. Multisets may contain multiple copies of the same number.
You would like to find a nonempty subset of A and a nonempty subset of B such that the sum of elements in these subsets are equal. Subsets are also multisets, i.e. they can contain elements with equal values.
If no solution exists, print - 1. Otherwise, print the indices of elements in any such subsets of A and B that have the same sum.
Input
The first line of the input contains a single integer n (1 β€ n β€ 1 000 000) β the size of both multisets.
The second line contains n integers, denoting the elements of A. Each element will be between 1 and n inclusive.
The third line contains n integers, denoting the elements of B. Each element will be between 1 and n inclusive.
Output
If there is no solution, print a single integer - 1. Otherwise, your solution should be printed on four lines.
The first line should contain a single integer ka, the size of the corresponding subset of A. The second line should contain ka distinct integers, the indices of the subset of A.
The third line should contain a single integer kb, the size of the corresponding subset of B. The fourth line should contain kb distinct integers, the indices of the subset of B.
Elements in both sets are numbered from 1 to n. If there are multiple possible solutions, print any of them.
Examples
Input
10
10 10 10 10 10 10 10 10 10 10
10 9 8 7 6 5 4 3 2 1
Output
1
2
3
5 8 10
Input
5
4 4 3 3 3
2 2 2 2 5
Output
2
2 3
2
3 5
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long x = 0, f = 1;
char c = getchar();
while (c > '9' || c < '0') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return f * x;
}
int n, l1, r1, l2, r2;
long long a[1000004], b[1000004];
bool flag = 0, vis[1000004];
pair<int, int> pos[1000004];
int main() {
n = read();
for (int i = 1; i <= n; ++i) a[i] = read() + a[i - 1];
for (int i = 1; i <= n; ++i) b[i] = read() + b[i - 1];
if (a[n] > b[n]) {
flag = 1;
for (int i = 1; i <= n; ++i) swap(a[i], b[i]);
}
int l = 0;
for (int i = 0; i <= n; ++i) {
while (l + 1 <= n && b[l + 1] <= a[i]) l++;
int now = a[i] - b[l];
if (vis[now]) {
l1 = pos[now].first + 1;
l2 = pos[now].second + 1;
r1 = i, r2 = l;
break;
} else {
vis[now] = 1;
pos[now] = make_pair(i, l);
}
}
if (flag) swap(l1, l2), swap(r1, r2);
cout << r1 - l1 + 1 << '\n';
for (int i = l1; i <= r1; ++i) cout << i << " ";
cout << '\n';
cout << r2 - l2 + 1 << '\n';
for (int i = l2; i <= r2; ++i) cout << i << " ";
cout << '\n';
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
You are given an undirected graph consisting of n vertices and <image> edges. Instead of giving you the edges that exist in the graph, we give you m unordered pairs (x, y) such that there is no edge between x and y, and if some pair of vertices is not listed in the input, then there is an edge between these vertices.
You have to find the number of connected components in the graph and the size of each component. A connected component is a set of vertices X such that for every two vertices from this set there exists at least one path in the graph connecting these vertices, but adding any other vertex to X violates this rule.
Input
The first line contains two integers n and m (1 β€ n β€ 200000, <image>).
Then m lines follow, each containing a pair of integers x and y (1 β€ x, y β€ n, x β y) denoting that there is no edge between x and y. Each pair is listed at most once; (x, y) and (y, x) are considered the same (so they are never listed in the same test). If some pair of vertices is not listed in the input, then there exists an edge between those vertices.
Output
Firstly print k β the number of connected components in this graph.
Then print k integers β the sizes of components. You should output these integers in non-descending order.
Example
Input
5 5
1 2
3 4
3 2
4 2
2 5
Output
2
1 4
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct DSU {
std::vector<int> dat;
DSU(int n) : dat(n, -1) {}
int find(int u) {
if (dat[u] < 0) return u;
return dat[u] = find(dat[u]);
}
void unite(int u, int v) {
u = find(u);
v = find(v);
if (u == v) return;
if (-dat[u] < -dat[v]) std::swap(u, v);
dat[u] += dat[v];
dat[v] = u;
}
int size(int u) { return -dat[find(u)]; }
};
const int N = 2e5;
set<int> g[N];
bool vis[N];
set<int> yet;
DSU dsu(N);
void dfs(int u) {
if (vis[u]) return;
vis[u] = true;
set<int> nxt;
vector<int> rem;
for (int v : yet) {
if (g[u].count(v)) {
nxt.insert(u);
} else {
dsu.unite(u, v);
rem.push_back(v);
}
}
for (int v : rem) yet.erase(v);
for (int v : rem) {
dfs(v);
}
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d %d", &u, &v);
u--;
v--;
g[u].insert(v);
g[v].insert(u);
}
for (int i = 0; i < n; i++) {
yet.insert(i);
}
for (int i = 0; i < n; i++) {
dfs(i);
}
vector<int> ans;
for (int i = 0; i < n; i++) {
if (dsu.find(i) == i) {
ans.push_back(dsu.size(i));
}
}
sort(ans.begin(), ans.end());
cout << ans.size() << endl;
for (int x : ans) {
printf("%d ", x);
}
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
There are N children, numbered 1, 2, \ldots, N.
They have decided to share K candies among themselves. Here, for each i (1 \leq i \leq N), Child i must receive between 0 and a_i candies (inclusive). Also, no candies should be left over.
Find the number of ways for them to share candies, modulo 10^9 + 7. Here, two ways are said to be different when there exists a child who receives a different number of candies.
Constraints
* All values in input are integers.
* 1 \leq N \leq 100
* 0 \leq K \leq 10^5
* 0 \leq a_i \leq K
Input
Input is given from Standard Input in the following format:
N K
a_1 a_2 \ldots a_N
Output
Print the number of ways for the children to share candies, modulo 10^9 + 7.
Examples
Input
3 4
1 2 3
Output
5
Input
1 10
9
Output
0
Input
2 0
0 0
Output
1
Input
4 100000
100000 100000 100000 100000
Output
665683269
### Response
```cpp
#include <iostream>
using namespace std;
int n, k, a;
int dp[101][1000001];
int pr[101][1000001];
int main()
{
cin >> n >> k;
dp[0][0] = 1;
for(int i = 0; i <= n; i++)
for(int j = 0; j <= k; j++)
pr[i][j] = 1;
for(int i = 1; i <= n; i++)
{
cin >> a;
dp[i][0] = 1;
for(int j = 1; j <= k; j++)
{
dp[i][j] = pr[i - 1][j];
if(j - a - 1 >= 0)
dp[i][j] = (dp[i][j] - pr[i - 1][j - a - 1] + int(1e9 + 7)) % int(1e9 + 7);
pr[i][j] = (pr[i][j - 1] + dp[i][j]) % int(1e9 + 7);
}
}
cout << dp[n][k] << endl;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
The nth triangular number is defined as the sum of the first n positive integers. The nth tetrahedral number is defined as the sum of the first n triangular numbers. It is easy to show that the nth tetrahedral number is equal to n(n+1)(n+2) β 6. For example, the 5th tetrahedral number is 1+(1+2)+(1+2+3)+(1+2+3+4)+(1+2+3+4+5) = 5Γ6Γ7 β 6 = 35.
The first 5 triangular numbers 1, 3, 6, 10, 15
Tr\[1\] Tr\[2\] Tr\[3\] Tr\[4\] Tr\[5\]
The first 5 tetrahedral numbers 1, 4, 10, 20, 35
Tet\[1\] Tet\[2\] Tet\[3\] Tet\[4\] Tet\[5\]
In 1850, Sir Frederick Pollock, 1st Baronet, who was not a professional mathematician but a British lawyer and Tory (currently known as Conservative) politician, conjectured that every positive integer can be represented as the sum of at most five tetrahedral numbers. Here, a tetrahedral number may occur in the sum more than once and, in such a case, each occurrence is counted separately. The conjecture has been open for more than one and a half century.
Your mission is to write a program to verify Pollock's conjecture for individual integers. Your program should make a calculation of the least number of tetrahedral numbers to represent each input integer as their sum. In addition, for some unknown reason, your program should make a similar calculation with only odd tetrahedral numbers available.
For example, one can represent 40 as the sum of 2 tetrahedral numbers, 4Γ5Γ6 β 6 + 4Γ5Γ6 β 6, but 40 itself is not a tetrahedral number. One can represent 40 as the sum of 6 odd tetrahedral numbers, 5Γ6Γ7 β 6 + 1Γ2Γ3 β 6 + 1Γ2Γ3 β 6 + 1Γ2Γ3 β 6 + 1Γ2Γ3 β 6 + 1Γ2Γ3 β 6, but cannot represent as the sum of fewer odd tetrahedral numbers. Thus, your program should report 2 and 6 if 40 is given.
Input
The input is a sequence of lines each of which contains a single positive integer less than 106. The end of the input is indicated by a line containing a single zero.
Output
For each input positive integer, output a line containing two integers separated by a space. The first integer should be the least number of tetrahedral numbers to represent the input integer as their sum. The second integer should be the least number of odd tetrahedral numbers to represent the input integer as their sum. No extra characters should appear in the output.
Sample Input
40
14
5
165
120
103
106
139
0
Output for the Sample Input
2 6
2 14
2 5
1 1
1 18
5 35
4 4
3 37
Example
Input
40
14
5
165
120
103
106
139
0
Output
2 6
2 14
2 5
1 1
1 18
5 35
4 4
3 37
### Response
```cpp
#include <iostream>
using namespace std;
#define rep(i, n) for(int i=0;i<(n);i++)
const int m = 1000001;
int dp[2][1000001];
int main() {
rep(i, 2)rep(j, m)dp[i][j] = j;
for(int i=1,a;a=i*(i+1)*(i+2)/6,a<m;i++)
rep(k, m-a) {
if(dp[0][k]< dp[0][k+a])dp[0][k+a] = dp[0][k] + 1;
if(a%2 && dp[1][k] < dp[1][k+a])dp[1][k+a] = dp[1][k] + 1;
}
for(int n;cin>>n,n;)cout<<dp[0][n]<<' '<<dp[1][n]<<endl;
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
You are given a set of n elements indexed from 1 to n. The weight of i-th element is wi. The weight of some subset of a given set is denoted as <image>. The weight of some partition R of a given set into k subsets is <image> (recall that a partition of a given set is a set of its subsets such that every element of the given set belongs to exactly one subset in partition).
Calculate the sum of weights of all partitions of a given set into exactly k non-empty subsets, and print it modulo 109 + 7. Two partitions are considered different iff there exist two elements x and y such that they belong to the same set in one of the partitions, and to different sets in another partition.
Input
The first line contains two integers n and k (1 β€ k β€ n β€ 2Β·105) β the number of elements and the number of subsets in each partition, respectively.
The second line contains n integers wi (1 β€ wi β€ 109)β weights of elements of the set.
Output
Print one integer β the sum of weights of all partitions of a given set into k non-empty subsets, taken modulo 109 + 7.
Examples
Input
4 2
2 3 2 3
Output
160
Input
5 2
1 2 3 4 5
Output
645
Note
Possible partitions in the first sample:
1. {{1, 2, 3}, {4}}, W(R) = 3Β·(w1 + w2 + w3) + 1Β·w4 = 24;
2. {{1, 2, 4}, {3}}, W(R) = 26;
3. {{1, 3, 4}, {2}}, W(R) = 24;
4. {{1, 2}, {3, 4}}, W(R) = 2Β·(w1 + w2) + 2Β·(w3 + w4) = 20;
5. {{1, 3}, {2, 4}}, W(R) = 20;
6. {{1, 4}, {2, 3}}, W(R) = 20;
7. {{1}, {2, 3, 4}}, W(R) = 26;
Possible partitions in the second sample:
1. {{1, 2, 3, 4}, {5}}, W(R) = 45;
2. {{1, 2, 3, 5}, {4}}, W(R) = 48;
3. {{1, 2, 4, 5}, {3}}, W(R) = 51;
4. {{1, 3, 4, 5}, {2}}, W(R) = 54;
5. {{2, 3, 4, 5}, {1}}, W(R) = 57;
6. {{1, 2, 3}, {4, 5}}, W(R) = 36;
7. {{1, 2, 4}, {3, 5}}, W(R) = 37;
8. {{1, 2, 5}, {3, 4}}, W(R) = 38;
9. {{1, 3, 4}, {2, 5}}, W(R) = 38;
10. {{1, 3, 5}, {2, 4}}, W(R) = 39;
11. {{1, 4, 5}, {2, 3}}, W(R) = 40;
12. {{2, 3, 4}, {1, 5}}, W(R) = 39;
13. {{2, 3, 5}, {1, 4}}, W(R) = 40;
14. {{2, 4, 5}, {1, 3}}, W(R) = 41;
15. {{3, 4, 5}, {1, 2}}, W(R) = 42.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
long long Mul(long long a, long long b) { return a * b % MOD; }
void Add(long long &a, long long b) {
a += b;
if (a >= MOD) a -= MOD;
}
long long gt[1001000], rev_gt[1001000];
long long POW(long long a, long long k) {
if (k == 0) return 1;
long long temp = POW(a, k >> 1);
temp = Mul(temp, temp);
if (k % 2) temp = Mul(temp, a);
return temp;
}
long long C(int k, int n) { return Mul(gt[n], Mul(rev_gt[k], rev_gt[n - k])); }
long long f(int n, int k) {
if (n < k) return 0;
int hs = 1;
if (k % 2) hs = -1;
long long ans = 0;
for (int i = (1); i <= (k); ++i) {
hs = -1 * hs;
long long now = Mul(C(i, k), POW(i, n));
if (hs == -1) now = MOD - now;
Add(ans, now);
}
return Mul(ans, rev_gt[k]);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, k;
cin >> n >> k;
gt[0] = 1;
for (int i = (1); i <= (n); ++i) gt[i] = Mul(gt[i - 1], i);
rev_gt[n] = POW(gt[n], MOD - 2);
for (int i = (n - 1); i >= (0); --i) rev_gt[i] = Mul(rev_gt[i + 1], i + 1);
long long sum = 0;
for (int i = (1); i <= (n); ++i) {
int x;
cin >> x;
Add(sum, x);
}
long long ans = f(n, k);
Add(ans, Mul(n - 1, f(n - 1, k)));
cout << Mul(ans, sum);
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
It is known that there are k fish species in the polar ocean, numbered from 1 to k. They are sorted by non-decreasing order of their weight, which is a positive number. Let the weight of the i-th type of fish be wi, then 0 < w1 β€ w2 β€ ... β€ wk holds.
Polar bears Alice and Bob each have caught some fish, and they are guessing who has the larger sum of weight of the fish he/she's caught. Given the type of the fish they've caught, determine whether it is possible that the fish caught by Alice has a strictly larger total weight than Bob's. In other words, does there exist a sequence of weights wi (not necessary integers), such that the fish caught by Alice has a strictly larger total weight?
Input
The first line contains three integers n, m, k (1 β€ n, m β€ 105, 1 β€ k β€ 109) β the number of fish caught by Alice and Bob respectively, and the number of fish species.
The second line contains n integers each from 1 to k, the list of fish type caught by Alice. The third line contains m integers each from 1 to k, the list of fish type caught by Bob.
Note that one may have caught more than one fish for a same species.
Output
Output "YES" (without quotes) if it is possible, and "NO" (without quotes) otherwise.
Examples
Input
3 3 3
2 2 2
1 1 3
Output
YES
Input
4 7 9
5 2 7 3
3 5 2 7 3 8 7
Output
NO
Note
In the first sample, if w1 = 1, w2 = 2, w3 = 2.5, then Alice has a total of 2 + 2 + 2 = 6 weight units, while Bob only has 1 + 1 + 2.5 = 4.5.
In the second sample, the fish that Alice caught is a subset of Bob's. Therefore, the total weight of Bobβs fish is always not less than the total weight of Aliceβs fish.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const inline int __GET_INT() {
int ret;
scanf("%d", &ret);
return ret;
}
int a[100005], b[100005];
int main() {
int n = __GET_INT(), m = __GET_INT(), k = __GET_INT();
for (int i = 0; i < n; ++i) a[i] = __GET_INT();
for (int i = 0; i < m; ++i) b[i] = __GET_INT();
if (n > m) {
puts("YES");
return 0;
}
sort(a, a + n);
sort(b, b + m);
int i = n - 1, j = m - 1, cnt1 = 0, cnt2 = 0;
while (i >= 0 && j >= 0) {
if (a[i] > b[j]) {
++cnt1;
--i;
} else if (a[i] < b[j]) {
++cnt2;
--j;
} else {
++cnt1;
++cnt2;
--i;
--j;
}
if (cnt1 > cnt2) {
puts("YES");
return 0;
}
}
puts("NO");
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
After his birthday party, Timofey went to his favorite tree alley in a park. He wants to feed there his favorite birds β crows.
It's widely known that each tree is occupied by a single crow family. The trees in the alley form a row and are numbered from 1 to n. Some families are friends to each other. For some reasons, two families can be friends only if they live not too far from each other, more precisely, there is no more than k - 1 trees between any pair of friend families. Formally, the family on the u-th tree and the family on the v-th tree can be friends only if |u - v| β€ k holds.
One of the friendship features is that if some family learns that Timofey is feeding crows somewhere, it notifies about this all friend families. Thus, after Timofey starts to feed crows under some tree, all the families that are friends to the family living on this tree, as well as their friends and so on, fly to the feeding place. Of course, the family living on the tree also comes to the feeding place.
Today Timofey came to the alley and noticed that all the families that live on trees with numbers strictly less than l or strictly greater than r have flown away. Thus, it is not possible to pass the information about feeding through them. Moreover, there is no need to feed them. Help Timofey to learn what is the minimum number of trees under which he has to feed crows so that all the families that have remained will get the information about feeding. You are given several situations, described by integers l and r, you need to calculate the answer for all of them.
Input
The first line contains integers n and k (1 β€ n β€ 105, 1 β€ k β€ 5), where n is the number of trees, and k is the maximum possible distance between friend families.
The next line contains single integer m (0 β€ m β€ nΒ·k) β the number of pair of friend families.
Each of the next m lines contains two integers u and v (1 β€ u, v β€ 105), that means that the families on trees u and v are friends. It is guaranteed that u β v and |u - v| β€ k. All the given pairs are distinct.
The next line contains single integer q (1 β€ q β€ 105) β the number of situations you need to calculate the answer in.
Each of the next q lines contains two integers l and r (1 β€ l β€ r β€ 105), that means that in this situation families that have flown away lived on such trees x, so that either x < l or x > r.
Output
Print q lines. Line i should contain single integer β the answer in the i-th situation.
Example
Input
5 3
3
1 3
2 3
4 5
5
1 1
1 2
2 3
1 3
1 5
Output
1
2
1
1
2
Note
In the first example the following family pairs are friends: (1, 3), (2, 3) and (4, 5).
* In the first situation only the first family has remained, so the answer is 1.
* In the second situation the first two families have remained, and they aren't friends, so the answer is 2.
* In the third situation the families 2 and 3 are friends, so it is enough to feed any of them, the answer is 1.
* In the fourth situation we can feed the first family, then the third family will get the information from the first family, and the second family will get the information from the third. The answer is 1.
* In the fifth situation we can feed the first and the fifth families, so the answer is 2.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
char READ_DATA;
int SIGNAL_INPUT;
template <typename Type>
inline char ru(Type &v) {
SIGNAL_INPUT = 1;
while ((READ_DATA = getchar()) < '0' || READ_DATA > '9')
if (READ_DATA == '-')
SIGNAL_INPUT = -1;
else if (READ_DATA == EOF)
return EOF;
v = READ_DATA - '0';
while ((READ_DATA = getchar()) >= '0' && READ_DATA <= '9')
v = v * 10 + READ_DATA - '0';
v *= SIGNAL_INPUT;
return 1;
}
template <typename A, typename B>
inline char ru(A &x, B &y) {
if (ru(x) == EOF) return EOF;
ru(y);
return 2;
}
template <typename A, typename B, typename C>
inline char ru(A &x, B &y, C &z) {
if (ru(x) == EOF) return EOF;
ru(y);
ru(z);
return 3;
}
template <typename A, typename B, typename C, typename D>
inline char ru(A &x, B &y, C &z, D &w) {
if (ru(x) == EOF) return EOF;
ru(y);
ru(z);
ru(w);
return 4;
}
struct Edge {
int u, v, next;
int w, p, cap, flow;
Edge(int _u = 0, int _v = 0, int nxt = -1, int _w = 1, int _cap = 0) {
u = _u;
v = _v;
w = _w;
cap = _cap;
flow = 0;
next = nxt;
}
};
int mod = 1e9 + 7;
const int maxn = 1e6 + 2;
const double pi = acos(-1.0);
Edge edg[maxn];
int cnt, g[maxn], lst[maxn];
int n, k, m, q;
struct BIT {
int n, t[maxn];
void add(int x, int d) {
while (x <= n) {
t[x] += d;
x += (x & -x);
}
}
int sum(int x) {
int ans = 0;
while (x) {
ans += t[x];
x -= (x & -x);
}
return ans;
}
} bit;
vector<int> edge[maxn];
vector<pair<int, int> > qry[maxn];
int p[maxn];
int find(int x) { return x == p[x] ? x : p[x] = find(p[x]); }
int pre[maxn];
int vis[maxn], tot;
void bfs(int u, int v) {
queue<int> q;
q.push(u);
vis[u] = tot;
pre[u] = -1;
while (!q.empty()) {
u = q.front();
q.pop();
Edge *e;
for (int i = g[u]; ~i && (e = &edg[i]); i = e->next) {
if (vis[e->v] != tot) {
q.push(e->v);
pre[e->v] = i;
vis[e->v] = tot;
if (e->v == v) break;
}
}
if (vis[v] == tot) break;
}
int mind = (1 << 30), mine;
for (int i = pre[v]; ~i; i = pre[edg[i].u]) {
if (edg[i].w < mind) {
mind = edg[i].w;
mine = i;
}
}
u = edg[mine].u;
v = edg[mine].v;
if (g[u] == mine)
g[u] = edg[mine].next;
else {
edg[lst[mine]].next = edg[mine].next;
lst[edg[mine].next] = lst[mine];
}
mine ^= 1;
if (g[v] == mine)
g[v] = edg[mine].next;
else {
edg[lst[mine]].next = edg[mine].next;
lst[edg[mine].next] = lst[mine];
}
bit.add(mind, -1);
}
int ans[maxn];
int main() {
memset(g, cnt = -1, sizeof(g));
memset(lst, -1, sizeof(lst));
int x, y;
ru(n, k);
bit.n = n;
for (int i = 1; i <= n; ++i) p[i] = i;
ru(m);
for (int i = 0; i < m; ++i) {
ru(x, y);
if (x > y) swap(x, y);
edge[y].push_back(x);
}
ru(q);
for (int i = 0; i < q; ++i) {
ru(x, y);
qry[y].push_back(pair<int, int>(i + 1, x));
}
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < edge[i].size(); ++j) {
x = edge[i][j];
y = i;
if (find(x) == find(y)) {
++tot;
bfs(x, y);
} else {
p[find(x)] = find(y);
}
if (~g[x]) lst[g[x]] = cnt + 1;
edg[++cnt] = Edge(x, y, g[x], x), g[x] = cnt;
if (~g[y]) lst[g[y]] = cnt + 1;
edg[++cnt] = Edge(y, x, g[y], x), g[y] = cnt;
bit.add(x, 1);
}
for (int j = 0; j < qry[i].size(); ++j) {
ans[qry[i][j].first] = i - qry[i][j].second + 1 -
(bit.sum(n) - bit.sum(qry[i][j].second - 1));
}
}
for (int i = 1; i <= q; ++i) printf("%d\n", ans[i]);
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
The legend of the foundation of Vectorland talks of two integers x and y. Centuries ago, the array king placed two markers at points |x| and |y| on the number line and conquered all the land in between (including the endpoints), which he declared to be Arrayland. Many years later, the vector king placed markers at points |x - y| and |x + y| and conquered all the land in between (including the endpoints), which he declared to be Vectorland. He did so in such a way that the land of Arrayland was completely inside (including the endpoints) the land of Vectorland.
Here |z| denotes the absolute value of z.
Now, Jose is stuck on a question of his history exam: "What are the values of x and y?" Jose doesn't know the answer, but he believes he has narrowed the possible answers down to n integers a_1, a_2, ..., a_n. Now, he wants to know the number of unordered pairs formed by two different elements from these n integers such that the legend could be true if x and y were equal to these two values. Note that it is possible that Jose is wrong, and that no pairs could possibly make the legend true.
Input
The first line contains a single integer n (2 β€ n β€ 2 β
10^5) β the number of choices.
The second line contains n pairwise distinct integers a_1, a_2, ..., a_n (-10^9 β€ a_i β€ 10^9) β the choices Jose is considering.
Output
Print a single integer number β the number of unordered pairs \\{x, y\} formed by different numbers from Jose's choices that could make the legend true.
Examples
Input
3
2 5 -3
Output
2
Input
2
3 6
Output
1
Note
Consider the first sample. For the pair \{2, 5\}, the situation looks as follows, with the Arrayland markers at |2| = 2 and |5| = 5, while the Vectorland markers are located at |2 - 5| = 3 and |2 + 5| = 7:
<image>
The legend is not true in this case, because the interval [2, 3] is not conquered by Vectorland. For the pair \{5, -3\} the situation looks as follows, with Arrayland consisting of the interval [3, 5] and Vectorland consisting of the interval [2, 8]:
<image>
As Vectorland completely contains Arrayland, the legend is true. It can also be shown that the legend is true for the pair \{2, -3\}, for a total of two pairs.
In the second sample, the only pair is \{3, 6\}, and the situation looks as follows:
<image>
Note that even though Arrayland and Vectorland share 3 as endpoint, we still consider Arrayland to be completely inside of Vectorland.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout.precision(15);
long long int n, x, low, mid = 0, high;
cin >> n;
vector<long long int> a(n);
for (long long int i = 0; i < n; i++) {
cin >> a[i];
a[i] = abs(a[i]);
}
sort((a).begin(), (a).end());
for (long long int i = 0; i < n; i++) {
auto it = upper_bound((a).begin(), (a).end(), 2 * a[i]);
mid += it - a.begin() - i - 1;
}
cout << mid;
return 0;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
Johnny is playing a well-known computer game. The game are in some country, where the player can freely travel, pass quests and gain an experience.
In that country there are n islands and m bridges between them, so you can travel from any island to any other. In the middle of some bridges are lying ancient powerful artifacts. Johnny is not interested in artifacts, but he can get some money by selling some artifact.
At the start Johnny is in the island a and the artifact-dealer is in the island b (possibly they are on the same island). Johnny wants to find some artifact, come to the dealer and sell it. The only difficulty is that bridges are too old and destroying right after passing over them. Johnnie's character can't swim, fly and teleport, so the problem became too difficult.
Note that Johnny can't pass the half of the bridge, collect the artifact and return to the same island.
Determine if Johnny can find some artifact and sell it.
Input
The first line contains two integers n and m (1 β€ n β€ 3Β·105, 0 β€ m β€ 3Β·105) β the number of islands and bridges in the game.
Each of the next m lines contains the description of the bridge β three integers xi, yi, zi (1 β€ xi, yi β€ n, xi β yi, 0 β€ zi β€ 1), where xi and yi are the islands connected by the i-th bridge, zi equals to one if that bridge contains an artifact and to zero otherwise. There are no more than one bridge between any pair of islands. It is guaranteed that it's possible to travel between any pair of islands.
The last line contains two integers a and b (1 β€ a, b β€ n) β the islands where are Johnny and the artifact-dealer respectively.
Output
If Johnny can find some artifact and sell it print the only word "YES" (without quotes). Otherwise print the word "NO" (without quotes).
Examples
Input
6 7
1 2 0
2 3 0
3 1 0
3 4 1
4 5 0
5 6 0
6 4 0
1 6
Output
YES
Input
5 4
1 2 0
2 3 0
3 4 0
2 5 1
1 4
Output
NO
Input
5 6
1 2 0
2 3 0
3 1 0
3 4 0
4 5 1
5 3 0
1 2
Output
YES
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int tin[1000000];
int timer;
int up[1000000];
vector<pair<int, int> > v1[1000000], v[1000000];
int colors, color[1000000];
int x[1000000];
int y[1000000];
int z[1000000];
int c[1000000];
int n, m;
int s, t;
set<pair<int, int> > edges;
void dfs(int x, int p) {
tin[x] = ++timer;
up[x] = tin[x];
for (int i = 0; i < v[x].size(); i++) {
int to = v[x][i].first;
if (to == p) continue;
if (tin[to])
up[x] = min(up[x], tin[to]);
else {
dfs(to, x);
up[x] = min(up[x], up[to]);
if (up[to] > tin[x]) {
edges.insert(make_pair(x, to));
}
}
}
}
void dfs2(int x, int y) {
color[x] = y;
for (int i = 0; i < v[x].size(); i++) {
int to = v[x][i].first;
if (color[to]) continue;
if (edges.count(make_pair(x, to)))
dfs2(to, ++colors);
else
dfs2(to, y);
}
}
void dfs3(int x, int k, int p) {
if (c[x]) k = 1;
if (x == color[t]) {
if (k) {
cout << "YES\n";
exit(0);
}
cout << "NO\n";
exit(0);
}
for (int i = 0; i < v1[x].size(); i++) {
int to = v1[x][i].first;
if (to == p) continue;
dfs3(to, k | v1[x][i].second, x);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> x[i] >> y[i] >> z[i];
v[x[i]].push_back(make_pair(y[i], z[i]));
v[y[i]].push_back(make_pair(x[i], z[i]));
}
cin >> s >> t;
dfs(s, 0);
dfs2(s, ++colors);
for (int i = 1; i <= m; i++) {
if (color[x[i]] == color[y[i]]) {
if (z[i]) c[color[x[i]]] = 1;
} else {
v1[color[x[i]]].push_back(make_pair(color[y[i]], z[i]));
v1[color[y[i]]].push_back(make_pair(color[x[i]], z[i]));
}
}
dfs3(color[s], 0, 0);
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
We have a tree with N vertices. The vertices are numbered 0 through N - 1, and the i-th edge (0 β€ i < N - 1) comnnects Vertex a_i and b_i. For each pair of vertices u and v (0 β€ u, v < N), we define the distance d(u, v) as the number of edges in the path u-v.
It is expected that one of the vertices will be invaded by aliens from outer space. Snuke wants to immediately identify that vertex when the invasion happens. To do so, he has decided to install an antenna on some vertices.
First, he decides the number of antennas, K (1 β€ K β€ N). Then, he chooses K different vertices, x_0, x_1, ..., x_{K - 1}, on which he installs Antenna 0, 1, ..., K - 1, respectively. If Vertex v is invaded by aliens, Antenna k (0 β€ k < K) will output the distance d(x_k, v). Based on these K outputs, Snuke will identify the vertex that is invaded. Thus, in order to identify the invaded vertex no matter which one is invaded, the following condition must hold:
* For each vertex u (0 β€ u < N), consider the vector (d(x_0, u), ..., d(x_{K - 1}, u)). These N vectors are distinct.
Find the minumum value of K, the number of antennas, when the condition is satisfied.
Constraints
* 2 β€ N β€ 10^5
* 0 β€ a_i, b_i < N
* The given graph is a tree.
Input
Input is given from Standard Input in the following format:
N
a_0 b_0
a_1 b_1
:
a_{N - 2} b_{N - 2}
Output
Print the minumum value of K, the number of antennas, when the condition is satisfied.
Examples
Input
5
0 1
0 2
0 3
3 4
Output
2
Input
2
0 1
Output
1
Input
10
2 8
6 0
4 1
7 6
2 3
8 6
6 9
2 4
5 8
Output
3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<int> edge[100010];
int dfs(int from, int par) {
int ret = 0, no = 0;
for(int to : edge[from]) {
if(to == par) continue;
int d = dfs(to, from);
ret += d;
if(d == 0) {
++no;
}
}
ret += max(0, no - 1);
return ret;
}
int main() {
int n; cin >> n;
for(int i = 0; i < n - 1; ++i) {
int a, b; cin >> a >> b;
edge[a].push_back(b);
edge[b].push_back(a);
}
int root = 0;
{
int maxi = 0;
for(int i = 0; i < n; ++i) {
int sz = edge[i].size();
if(sz > maxi) {
root = i;
maxi = sz;
}
}
if(maxi <= 2) {
cout << 1 << '\n';
return 0;
}
}
cout << dfs(root, -1) << '\n';
return 0;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
Ostap already settled down in Rio de Janiero suburb and started to grow a tree in his garden. Recall that a tree is a connected undirected acyclic graph.
Ostap's tree now has n vertices. He wants to paint some vertices of the tree black such that from any vertex u there is at least one black vertex v at distance no more than k. Distance between two vertices of the tree is the minimum possible number of edges of the path between them.
As this number of ways to paint the tree can be large, Ostap wants you to compute it modulo 109 + 7. Two ways to paint the tree are considered different if there exists a vertex that is painted black in one way and is not painted in the other one.
Input
The first line of the input contains two integers n and k (1 β€ n β€ 100, 0 β€ k β€ min(20, n - 1)) β the number of vertices in Ostap's tree and the maximum allowed distance to the nearest black vertex. Don't miss the unusual constraint for k.
Each of the next n - 1 lines contain two integers ui and vi (1 β€ ui, vi β€ n) β indices of vertices, connected by the i-th edge. It's guaranteed that given graph is a tree.
Output
Print one integer β the remainder of division of the number of ways to paint the tree by 1 000 000 007 (109 + 7).
Examples
Input
2 0
1 2
Output
1
Input
2 1
1 2
Output
3
Input
4 1
1 2
2 3
3 4
Output
9
Input
7 2
1 2
2 3
1 4
4 5
1 6
6 7
Output
91
Note
In the first sample, Ostap has to paint both vertices black.
In the second sample, it is enough to paint only one of two vertices, thus the answer is 3: Ostap can paint only vertex 1, only vertex 2, vertices 1 and 2 both.
In the third sample, the valid ways to paint vertices are: {1, 3}, {1, 4}, {2, 3}, {2, 4}, {1, 2, 3}, {1, 2, 4}, {1, 3, 4}, {2, 3, 4}, {1, 2, 3, 4}.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T inverse(T a, T m) {
T u = 0, v = 1;
while (a != 0) {
T t = m / a;
m -= t * a;
swap(a, m);
u -= t * v;
swap(u, v);
}
assert(m == 1);
return u;
}
template <typename T>
class Modular {
public:
using Type = typename decay<decltype(T::value)>::type;
constexpr Modular() : value() {}
template <typename U>
Modular(const U& x) {
value = normalize(x);
}
template <typename U>
static Type normalize(const U& x) {
Type v;
if (-mod() <= x && x < mod())
v = static_cast<Type>(x);
else
v = static_cast<Type>(x % mod());
if (v < 0) v += mod();
return v;
}
const Type& operator()() const { return value; }
template <typename U>
explicit operator U() const {
return static_cast<U>(value);
}
constexpr static Type mod() { return T::value; }
Modular& operator+=(const Modular& other) {
if ((value += other.value) >= mod()) value -= mod();
return *this;
}
Modular& operator-=(const Modular& other) {
if ((value -= other.value) < 0) value += mod();
return *this;
}
template <typename U>
Modular& operator+=(const U& other) {
return *this += Modular(other);
}
template <typename U>
Modular& operator-=(const U& other) {
return *this -= Modular(other);
}
Modular& operator++() { return *this += 1; }
Modular& operator--() { return *this -= 1; }
Modular operator++(int) {
Modular result(*this);
*this += 1;
return result;
}
Modular operator--(int) {
Modular result(*this);
*this -= 1;
return result;
}
Modular operator-() const { return Modular(-value); }
template <typename U = T>
typename enable_if<is_same<typename Modular<U>::Type, int>::value,
Modular>::type&
operator*=(const Modular& rhs) {
value = normalize(static_cast<int64_t>(value) *
static_cast<int64_t>(rhs.value));
return *this;
}
template <typename U = T>
typename enable_if<is_same<typename Modular<U>::Type, int64_t>::value,
Modular>::type&
operator*=(const Modular& rhs) {
int64_t q = static_cast<int64_t>(static_cast<long double>(value) *
rhs.value / mod());
value = normalize(value * rhs.value - q * mod());
return *this;
}
template <typename U = T>
typename enable_if<!is_integral<typename Modular<U>::Type>::value,
Modular>::type&
operator*=(const Modular& rhs) {
value = normalize(value * rhs.value);
return *this;
}
Modular& operator/=(const Modular& other) {
return *this *= Modular(inverse(other.value, mod()));
}
template <typename U>
friend bool operator==(const Modular<U>& lhs, const Modular<U>& rhs);
template <typename U>
friend bool operator<(const Modular<U>& lhs, const Modular<U>& rhs);
template <typename U>
friend std::istream& operator>>(std::istream& stream, Modular<U>& number);
private:
Type value;
};
template <typename T>
bool operator==(const Modular<T>& lhs, const Modular<T>& rhs) {
return lhs.value == rhs.value;
}
template <typename T, typename U>
bool operator==(const Modular<T>& lhs, U rhs) {
return lhs == Modular<T>(rhs);
}
template <typename T, typename U>
bool operator==(U lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) == rhs;
}
template <typename T>
bool operator!=(const Modular<T>& lhs, const Modular<T>& rhs) {
return !(lhs == rhs);
}
template <typename T, typename U>
bool operator!=(const Modular<T>& lhs, U rhs) {
return !(lhs == rhs);
}
template <typename T, typename U>
bool operator!=(U lhs, const Modular<T>& rhs) {
return !(lhs == rhs);
}
template <typename T>
bool operator<(const Modular<T>& lhs, const Modular<T>& rhs) {
return lhs.value < rhs.value;
}
template <typename T>
Modular<T> operator+(const Modular<T>& lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) += rhs;
}
template <typename T, typename U>
Modular<T> operator+(const Modular<T>& lhs, U rhs) {
return Modular<T>(lhs) += rhs;
}
template <typename T, typename U>
Modular<T> operator+(U lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) += rhs;
}
template <typename T>
Modular<T> operator-(const Modular<T>& lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) -= rhs;
}
template <typename T, typename U>
Modular<T> operator-(const Modular<T>& lhs, U rhs) {
return Modular<T>(lhs) -= rhs;
}
template <typename T, typename U>
Modular<T> operator-(U lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) -= rhs;
}
template <typename T>
Modular<T> operator*(const Modular<T>& lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) *= rhs;
}
template <typename T, typename U>
Modular<T> operator*(const Modular<T>& lhs, U rhs) {
return Modular<T>(lhs) *= rhs;
}
template <typename T, typename U>
Modular<T> operator*(U lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) *= rhs;
}
template <typename T>
Modular<T> operator/(const Modular<T>& lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) /= rhs;
}
template <typename T, typename U>
Modular<T> operator/(const Modular<T>& lhs, U rhs) {
return Modular<T>(lhs) /= rhs;
}
template <typename T, typename U>
Modular<T> operator/(U lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) /= rhs;
}
template <typename T, typename U>
Modular<T> power(const Modular<T>& a, const U& b) {
assert(b >= 0);
Modular<T> x = a, res = 1;
U p = b;
while (p > 0) {
if (p & 1) res *= x;
x *= x;
p >>= 1;
}
return res;
}
template <typename T>
string to_string(const Modular<T>& number) {
return to_string(number());
}
template <typename T>
std::ostream& operator<<(std::ostream& stream, const Modular<T>& number) {
return stream << number();
}
template <typename T>
std::istream& operator>>(std::istream& stream, Modular<T>& number) {
typename common_type<typename Modular<T>::Type, int64_t>::type x;
stream >> x;
number.value = Modular<T>::normalize(x);
return stream;
}
constexpr int md = (int)1e9 + 7;
using Mint = Modular<std::integral_constant<decay<decltype(md)>::type, md>>;
template <typename T>
void debug_out(T t) {
cerr << t;
}
template <typename A, typename B>
void debug_out(pair<A, B> u) {
cerr << "(" << u.first << " " << u.second << ")";
}
template <typename T>
void debug_out(vector<T> t) {
int sz = t.size();
for (int i = 0; i < sz; i++) {
debug_out(t[i]);
if (i != sz - 1) cerr << ", ";
}
}
template <typename T>
void debug_out(vector<vector<T>> t) {
int sz = t.size();
for (int i = 0; i < sz; i++) {
debug_out(t[i]);
if (i != sz - 1) cerr << endl;
}
}
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
debug_out(H);
cerr << " ";
debug_out(T...);
}
template <typename T>
void debug_out(set<T> a) {
vector<T> _a;
for (T t : a) _a.push_back(t);
debug_out(_a);
}
int n, k;
int main() {
cin >> n >> k;
vector<vector<int>> g(n);
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
g[u].push_back(v);
g[v].push_back(u);
}
if (k == 0) {
cout << 1;
return 0;
}
auto merge = [&](vector<vector<Mint>> a, vector<vector<Mint>> b) {
int sa = a.size();
int sb = b.size();
vector<vector<Mint>> res(max(sa, sb + 1), vector<Mint>(max(sa, sb + 1)));
for (int i = 0; i < sa; i++) {
for (int j = 0; j < sa; j++) {
for (int x = 0; x < sb; x++) {
for (int y = 0; y < sb; y++) {
int ti = (i == sa - 1 ? -1 : i);
int tj = (j == sa - 1 ? INT_MAX : j);
int tx = (x == sb - 1 ? -1 : x + 1);
int ty = (y == sb - 1 ? INT_MAX : y + 1);
int rx = max(ti, tx), ry = min(tj, ty);
if (rx == -1 || ry <= k - rx) rx = max(sa - 1, sb);
if (ry == INT_MAX) ry = max(sa - 1, sb);
res[rx][ry] += a[i][j] * b[x][y];
}
}
}
}
return res;
};
function<vector<vector<Mint>>(int, int)> dfs = [&](int x, int par) {
vector<vector<Mint>> res = {{0, 1}, {1, 0}};
for (int i : g[x]) {
if (i == par) continue;
res = merge(res, dfs(i, x));
}
return res;
};
vector<vector<Mint>> res = dfs(0, -1);
Mint ans = 0;
int sz = res.size();
for (int i = 0; i < sz; i++) ans += res[sz - 1][i];
cout << ans;
return 0;
}
``` |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.