text
stringlengths 424
69.5k
|
|---|
### Prompt
Your challenge is to write a CPP solution to the following problem:
A magic number is a number formed by concatenation of numbers 1, 14 and 144. We can use each of these numbers any number of times. Therefore 14144, 141414 and 1411 are magic numbers but 1444, 514 and 414 are not.
You're given a number. Determine if it is a magic number or not.
Input
The first line of input contains an integer n, (1 β€ n β€ 109). This number doesn't contain leading zeros.
Output
Print "YES" if n is a magic number or print "NO" if it's not.
Examples
Input
114114
Output
YES
Input
1111
Output
YES
Input
441231
Output
NO
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<int> element, element1;
list<int> datal;
stack<int> datas;
queue<int> dataq;
map<string, int> datam;
set<int> datase;
vector<int>::iterator itv;
list<int>::iterator itl;
map<string, int>::iterator itm;
set<int>::iterator itse;
int main() {
int i, len;
string text;
while (cin >> text) {
len = text.size();
char ch;
ch = char(text[0]);
if (ch != '1') {
cout << "NO" << endl;
continue;
}
int count = 0, help = 0;
string str = "1";
for (i = 1; i < len; i++) {
if (text[i] == '1') {
str.clear();
str = "";
str += "1";
help = 0;
} else if ((text[i] == '4') && (help == 0)) {
str += "4";
if (str == "144") {
str.clear();
help = 1;
}
} else {
cout << "NO" << endl;
count = 1;
break;
}
}
if (count == 0) cout << "YES" << endl;
str.clear();
}
return (0);
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
Anatoly lives in the university dorm as many other students do. As you know, cockroaches are also living there together with students. Cockroaches might be of two colors: black and red. There are n cockroaches living in Anatoly's room.
Anatoly just made all his cockroaches to form a single line. As he is a perfectionist, he would like the colors of cockroaches in the line to alternate. He has a can of black paint and a can of red paint. In one turn he can either swap any two cockroaches, or take any single cockroach and change it's color.
Help Anatoly find out the minimum number of turns he needs to make the colors of cockroaches in the line alternate.
Input
The first line of the input contains a single integer n (1 β€ n β€ 100 000) β the number of cockroaches.
The second line contains a string of length n, consisting of characters 'b' and 'r' that denote black cockroach and red cockroach respectively.
Output
Print one integer β the minimum number of moves Anatoly has to perform in order to make the colors of cockroaches in the line to alternate.
Examples
Input
5
rbbrr
Output
1
Input
5
bbbbb
Output
2
Input
3
rbr
Output
0
Note
In the first sample, Anatoly has to swap third and fourth cockroaches. He needs 1 turn to do this.
In the second sample, the optimum answer is to paint the second and the fourth cockroaches red. This requires 2 turns.
In the third sample, the colors of cockroaches in the line are alternating already, thus the answer is 0.
### Response
```cpp
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int N = 1e2 + 17, M = 1e3 + 5, OO = 0x3f3f3f3f;
int n, ans, pr1 = 0, pb1 = 0, pr2 = 0, pb2 = 0;
string s;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> s;
for (int i = 0; i < n; i++) {
if (i & 1 && s[i] != 'r')
pb1++;
else if (!(i & 1) && s[i] != 'b')
pr1++;
}
for (int i = 0; i < n; i++) {
if (i & 1 && s[i] != 'b')
pr2++;
else if (!(i & 1) && s[i] != 'r')
pb2++;
}
cout << min(abs(pr1 - pb1) + min(pr1, pb1), abs(pr2 - pb2) + min(pr2, pb2));
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
You are given three multisets of pairs of colored sticks:
* R pairs of red sticks, the first pair has length r_1, the second pair has length r_2, ..., the R-th pair has length r_R;
* G pairs of green sticks, the first pair has length g_1, the second pair has length g_2, ..., the G-th pair has length g_G;
* B pairs of blue sticks, the first pair has length b_1, the second pair has length b_2, ..., the B-th pair has length b_B;
You are constructing rectangles from these pairs of sticks with the following process:
1. take a pair of sticks of one color;
2. take a pair of sticks of another color different from the first one;
3. add the area of the resulting rectangle to the total area.
Thus, you get such rectangles that their opposite sides are the same color and their adjacent sides are not the same color.
Each pair of sticks can be used at most once, some pairs can be left unused. You are not allowed to split a pair into independent sticks.
What is the maximum area you can achieve?
Input
The first line contains three integers R, G, B (1 β€ R, G, B β€ 200) β the number of pairs of red sticks, the number of pairs of green sticks and the number of pairs of blue sticks.
The second line contains R integers r_1, r_2, ..., r_R (1 β€ r_i β€ 2000) β the lengths of sticks in each pair of red sticks.
The third line contains G integers g_1, g_2, ..., g_G (1 β€ g_i β€ 2000) β the lengths of sticks in each pair of green sticks.
The fourth line contains B integers b_1, b_2, ..., b_B (1 β€ b_i β€ 2000) β the lengths of sticks in each pair of blue sticks.
Output
Print the maximum possible total area of the constructed rectangles.
Examples
Input
1 1 1
3
5
4
Output
20
Input
2 1 3
9 5
1
2 8 5
Output
99
Input
10 1 1
11 7 20 15 19 14 2 4 13 14
8
11
Output
372
Note
In the first example you can construct one of these rectangles: red and green with sides 3 and 5, red and blue with sides 3 and 4 and green and blue with sides 5 and 4. The best area of them is 4 Γ 5 = 20.
In the second example the best rectangles are: red/blue 9 Γ 8, red/blue 5 Γ 5, green/blue 2 Γ 1. So the total area is 72 + 25 + 2 = 99.
In the third example the best rectangles are: red/green 19 Γ 8 and red/blue 20 Γ 11. The total area is 152 + 220 = 372. Note that you can't construct more rectangles because you are not allowed to have both pairs taken to be the same color.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int A, B, C;
int a[205], b[205], c[205];
int dp[201][201][201];
inline void chmax(int &aa, int xx) {
if (xx > aa) aa = xx;
}
int main() {
ios::sync_with_stdio(false);
cin >> A >> B >> C;
for (int i = 1; i <= A; ++i) cin >> a[i];
for (int i = 1; i <= B; ++i) cin >> b[i];
for (int i = 1; i <= C; ++i) cin >> c[i];
sort(a + 1, a + A + 1);
reverse(a + 1, a + A + 1);
sort(b + 1, b + B + 1);
reverse(b + 1, b + B + 1);
sort(c + 1, c + C + 1);
reverse(c + 1, c + C + 1);
int ans = 0;
for (int i = 0; i < A + 1; ++i)
for (int j = 0; j < B + 1; ++j)
for (int k = 0; k < C + 1; ++k) {
if (i < A && j < B)
chmax(dp[i + 1][j + 1][k], dp[i][j][k] + a[i + 1] * b[j + 1]);
if (j < B && k < C)
chmax(dp[i][j + 1][k + 1], dp[i][j][k] + b[j + 1] * c[k + 1]);
if (k < C && i < A)
chmax(dp[i + 1][j][k + 1], dp[i][j][k] + c[k + 1] * a[i + 1]);
ans = max(ans, dp[i][j][k]);
}
cout << ans << endl;
return 0;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
Recenlty Luba got a credit card and started to use it. Let's consider n consecutive days Luba uses the card.
She starts with 0 money on her account.
In the evening of i-th day a transaction ai occurs. If ai > 0, then ai bourles are deposited to Luba's account. If ai < 0, then ai bourles are withdrawn. And if ai = 0, then the amount of money on Luba's account is checked.
In the morning of any of n days Luba can go to the bank and deposit any positive integer amount of burles to her account. But there is a limitation: the amount of money on the account can never exceed d.
It can happen that the amount of money goes greater than d by some transaction in the evening. In this case answer will be Β«-1Β».
Luba must not exceed this limit, and also she wants that every day her account is checked (the days when ai = 0) the amount of money on her account is non-negative. It takes a lot of time to go to the bank, so Luba wants to know the minimum number of days she needs to deposit some money to her account (if it is possible to meet all the requirements). Help her!
Input
The first line contains two integers n, d (1 β€ n β€ 105, 1 β€ d β€ 109) βthe number of days and the money limitation.
The second line contains n integer numbers a1, a2, ... an ( - 104 β€ ai β€ 104), where ai represents the transaction in i-th day.
Output
Print -1 if Luba cannot deposit the money to her account in such a way that the requirements are met. Otherwise print the minimum number of days Luba has to deposit money.
Examples
Input
5 10
-1 5 0 -5 3
Output
0
Input
3 4
-10 0 20
Output
-1
Input
5 10
-5 0 10 -11 0
Output
2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
constexpr long long maxN = 1e5 + 43;
long long n, d;
vector<long long> a;
long long suff[maxN];
long long had_max[maxN];
signed main() {
ios_base::sync_with_stdio(false);
cin >> n >> d;
a.resize(n + 1);
for (long long i = 1; i <= n; ++i) cin >> a[i];
long long ans = 0;
long long maxx = 0, minn = 0;
for (long long i = 1; i <= n; ++i) {
if (a[i] != 0) {
maxx += a[i];
minn += a[i];
maxx = min(maxx, d);
if (minn > d) {
cout << -1;
return 0;
}
} else {
if (maxx < 0) {
maxx = d;
minn = 0;
++ans;
} else {
minn = max((long long)0, minn);
}
}
}
cout << ans;
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
This problem uses a simplified network topology model, please read the problem statement carefully and use it as a formal document as you develop the solution.
Polycarpus continues working as a system administrator in a large corporation. The computer network of this corporation consists of n computers, some of them are connected by a cable. The computers are indexed by integers from 1 to n. It's known that any two computers connected by cable directly or through other computers
Polycarpus decided to find out the network's topology. A network topology is the way of describing the network configuration, the scheme that shows the location and the connections of network devices.
Polycarpus knows three main network topologies: bus, ring and star. A bus is the topology that represents a shared cable with all computers connected with it. In the ring topology the cable connects each computer only with two other ones. A star is the topology where all computers of a network are connected to the single central node.
Let's represent each of these network topologies as a connected non-directed graph. A bus is a connected graph that is the only path, that is, the graph where all nodes are connected with two other ones except for some two nodes that are the beginning and the end of the path. A ring is a connected graph, where all nodes are connected with two other ones. A star is a connected graph, where a single central node is singled out and connected with all other nodes. For clarifications, see the picture.
<image> (1) β bus, (2) β ring, (3) β star
You've got a connected non-directed graph that characterizes the computer network in Polycarpus' corporation. Help him find out, which topology type the given network is. If that is impossible to do, say that the network's topology is unknown.
Input
The first line contains two space-separated integers n and m (4 β€ n β€ 105; 3 β€ m β€ 105) β the number of nodes and edges in the graph, correspondingly. Next m lines contain the description of the graph's edges. The i-th line contains a space-separated pair of integers xi, yi (1 β€ xi, yi β€ n) β the numbers of nodes that are connected by the i-the edge.
It is guaranteed that the given graph is connected. There is at most one edge between any two nodes. No edge connects a node with itself.
Output
In a single line print the network topology name of the given graph. If the answer is the bus, print "bus topology" (without the quotes), if the answer is the ring, print "ring topology" (without the quotes), if the answer is the star, print "star topology" (without the quotes). If no answer fits, print "unknown topology" (without the quotes).
Examples
Input
4 3
1 2
2 3
3 4
Output
bus topology
Input
4 4
1 2
2 3
3 4
4 1
Output
ring topology
Input
4 3
1 2
1 3
1 4
Output
star topology
Input
4 4
1 2
2 3
3 1
1 4
Output
unknown topology
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m;
int con[100010];
int st, ri, bu, cnt, si;
int main() {
scanf("%d %d", &n, &m);
int x, y;
for (int i = 1; i <= m; i++) {
scanf("%d %d", &x, &y);
con[x]++;
con[y]++;
}
for (int i = 1; i <= n; i++) {
if (con[i] == n - 1 && st == 1) st = -1;
if (con[i] == n - 1 && !st) st = 1;
if (con[i] > 1 && con[i] != n - 1) st = -1;
if (con[i] == 1) si++;
if (con[i] == 2) cnt++;
}
if (cnt == n)
cout << "ring topology" << endl;
else if (cnt == n - 2 && si == 2)
cout << "bus topology" << endl;
else if (st == 1)
cout << "star topology" << endl;
else
cout << "unknown topology" << endl;
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Wind Corridor is a covered passageway where strong wind is always blowing. It is a long corridor of width W, and there are several pillars in it. Each pillar is a right prism and its face is a polygon (not necessarily convex).
In this problem, we consider two-dimensional space where the positive x-axis points the east and the positive y-axis points the north. The passageway spans from the south to the north, and its length is infinity. Specifically, it covers the area 0 β€ x β€ W. The outside of the passageway is filled with walls. Each pillar is expressed as a polygon, and all the pillars are located within the corridor without conflicting or touching each other.
Wind blows from the south side of the corridor to the north. For each second, w unit volume of air can be flowed at most if the minimum width of the path of the wind is w. Note that the path may fork and merge, but never overlaps with pillars and walls.
Your task in this problem is to write a program that calculates the maximum amount of air that can be flowed through the corridor per second.
Input
The input consists of multiple datasets. Each dataset has the following format:
The first line of the input contains two integers W and N. W is the width of the corridor, and N is the number of pillars. W and N satisfy the following condition: 1 β€ W β€ 104 and 0 β€ N β€ 200.
Then, N specifications of each pillar follow. Each specification starts with a line that contains a single integer M, which is the number of the vertices of a polygon (3 β€ M β€ 40). The following M lines describe the shape of the polygon. The i-th line (1 β€ i β€ M) contains two integers xi and yi that denote the coordinate of the i-th vertex (0 < xi < W, 0 < yi < 104).
The last dataset is followed by a line containing two zeros. This line is not a part of any dataset and should not be processed.
Output
For each dataset, your program should print a line that contains the maximum amount of air flow per second, in unit volume. The output may contain arbitrary number of digits after the decimal point, but the absolute error must not exceed 10-6.
Example
Input
5 2
4
1 1
1 2
2 2
2 1
4
3 3
3 4
4 4
4 3
0 0
Output
3.41421356
### Response
```cpp
#include<bits/stdc++.h>
#define EQ(a,b) (abs((a)-(b)) < EPS)
#define rep(i,n) for(int i=0;i<(int)(n);i++)
#define fs first
#define sc second
#define pb push_back
#define sz size()
#define all(a) (a).begin(),(a).end()
using namespace std;
typedef double D;
typedef complex<D> P;
typedef pair<P,P> L;
typedef pair<D,int> pdi;
const D EPS = 1e-8;
const D PI = acos(-1);
inline D dot(P x, P y){return real(conj(x)*y);}
inline D cross(P x, P y){return imag(conj(x)*y);}
inline D seg_p_dis(L a,P x){
if(dot(a.sc-a.fs,x-a.fs)<EPS)return abs(x-a.fs);
if(dot(a.fs-a.sc,x-a.sc)<EPS)return abs(x-a.sc);
return abs(cross(a.sc-a.fs,x-a.fs))/abs(a.sc-a.fs);
}
inline D seg_seg_dis(L a,L b){
D res = 1e10;
res = min(res,seg_p_dis(a,b.fs));
res = min(res,seg_p_dis(a,b.sc));
res = min(res,seg_p_dis(b,a.fs));
res = min(res,seg_p_dis(b,a.sc));
return res;
}
int main(){
int w,n;
while(cin >> w >> n){
if(w==0)return 0;
vector< vector<L> > l(n);
rep(i,n){
int m;
cin >> m;
vector<P> p(m);
rep(j,m){
int x,y;
cin >> x >> y;
p[j] = P(x,y);
}
rep(j,m){
l[i].push_back(L(p[j],p[(j+1)%m]));
}
}
int v = n+2;
vector< vector<pdi> > g(v);
g[v-2].pb(pdi(w,v-1));
L ls = L(P(0,0),P(0,1e4)), lt = L(P(w,0),P(w,1e4));
rep(i,n){
D dis = w;
for(L a : l[i])dis = min(dis, seg_seg_dis(ls,a));
g[v-2].pb(pdi(dis, i));
dis = w;
for(L a : l[i])dis = min(dis, seg_seg_dis(lt,a));
g[i].pb(pdi(dis,v-1));
rep(j,i){
dis = w;
for(L a : l[i])for(L b : l[j]){
dis = min(dis, seg_seg_dis(a,b));
}
g[i].pb(pdi(dis,j)); g[j].pb(pdi(dis,i));
}
}
vector<D> d(v,1e9);
d[v-2] = 0;
priority_queue<pdi, vector<pdi>, greater<pdi> > q;
q.push(pdi(0,v-2));
while(q.size()){
pdi p = q.top(); q.pop();
D cost = p.fs;
int cur = p.sc;
if(cur == v-1)break;
if(d[cur]+EPS < cost)continue;
for(pdi nxt : g[cur]){
D ncost = cost + nxt.fs;
int u = nxt.sc;
if(d[u] > ncost + EPS){
d[u] = ncost;
q.push(pdi(ncost,u));
}
}
}
cout << fixed << setprecision(9) << d[v-1] << endl;
}
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
There are N towns in Snuke Kingdom, conveniently numbered 1 through N. Town 1 is the capital.
Each town in the kingdom has a Teleporter, a facility that instantly transports a person to another place. The destination of the Teleporter of town i is town a_i (1β€a_iβ€N). It is guaranteed that one can get to the capital from any town by using the Teleporters some number of times.
King Snuke loves the integer K. The selfish king wants to change the destination of the Teleporters so that the following holds:
* Starting from any town, one will be at the capital after using the Teleporters exactly K times in total.
Find the minimum number of the Teleporters whose destinations need to be changed in order to satisfy the king's desire.
Constraints
* 2β€Nβ€10^5
* 1β€a_iβ€N
* One can get to the capital from any town by using the Teleporters some number of times.
* 1β€Kβ€10^9
Input
The input is given from Standard Input in the following format:
N K
a_1 a_2 ... a_N
Output
Print the minimum number of the Teleporters whose destinations need to be changed in order to satisfy King Snuke's desire.
Examples
Input
3 1
2 3 1
Output
2
Input
4 2
1 1 2 2
Output
0
Input
8 2
4 1 2 3 1 2 3 4
Output
3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n,m,i,j,a[100005],ans;
vector <int> edge[100005];
int dfs(int id, int p){
int mx = 0;
for(int ii = 0; ii < edge[id].size(); ii++)
mx = max(mx, dfs(edge[id][ii], id));
if(p != 1){
if(mx + 1 == m){
a[id] = 1;
ans++;
return 0;
}
}
return mx + 1;
}
int main(){
scanf("%d%d", &n, &m);
for(i = 1; i <= n; i++){
int x;
scanf("%d", &x);
a[i] = x;
if(i != 1)
edge[x].push_back(i);
}
dfs(1, 1);
ans += (a[1] != 1);
printf("%d\n", ans);
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
The organizers of a programming contest have decided to present t-shirts to participants. There are six different t-shirts sizes in this problem: S, M, L, XL, XXL, XXXL (sizes are listed in increasing order). The t-shirts are already prepared. For each size from S to XXXL you are given the number of t-shirts of this size.
During the registration, the organizers asked each of the n participants about the t-shirt size he wants. If a participant hesitated between two sizes, he could specify two neighboring sizes β this means that any of these two sizes suits him.
Write a program that will determine whether it is possible to present a t-shirt to each participant of the competition, or not. Of course, each participant should get a t-shirt of proper size:
* the size he wanted, if he specified one size;
* any of the two neibouring sizes, if he specified two sizes.
If it is possible, the program should find any valid distribution of the t-shirts.
Input
The first line of the input contains six non-negative integers β the number of t-shirts of each size. The numbers are given for the sizes S, M, L, XL, XXL, XXXL, respectively. The total number of t-shirts doesn't exceed 100 000.
The second line contains positive integer n (1 β€ n β€ 100 000) β the number of participants.
The following n lines contain the sizes specified by the participants, one line per participant. The i-th line contains information provided by the i-th participant: single size or two sizes separated by comma (without any spaces). If there are two sizes, the sizes are written in increasing order. It is guaranteed that two sizes separated by comma are neighboring.
Output
If it is not possible to present a t-shirt to each participant, print Β«NOΒ» (without quotes).
Otherwise, print n + 1 lines. In the first line print Β«YESΒ» (without quotes). In the following n lines print the t-shirt sizes the orginizers should give to participants, one per line. The order of the participants should be the same as in the input.
If there are multiple solutions, print any of them.
Examples
Input
0 1 0 1 1 0
3
XL
S,M
XL,XXL
Output
YES
XL
M
XXL
Input
1 1 2 0 1 1
5
S
M
S,M
XXL,XXXL
XL,XXL
Output
NO
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <class X, class Y>
void minimize(X &x, const Y &y) {
if (x > y) x = y;
}
template <class X, class Y>
void maximize(X &x, const Y &y) {
if (x < y) x = y;
}
template <class T>
T Abs(const T &x) {
return (x < 0 ? -x : x);
}
const string yes = "YES";
const string no = "NO";
const string sizeName[] = {"S", "M", "L", "XL", "XXL", "XXXL"};
const int numSize = 6;
vector<int> singleReq[10], doubleReq[10];
string answer[100100];
int have[10], n;
void noAnswer(void) {
cout << "NO" << endl;
exit(0);
}
void process(void) {
for (int i = 0, _n = (numSize); i < _n; i = i + 1) cin >> have[i];
cin >> n;
for (int i = (1), _b = (n); i <= _b; i = i + 1) {
string req;
cin >> req;
for (int j = 0, _n = (numSize); j < _n; j = j + 1)
if (req == sizeName[j]) singleReq[j].push_back(i);
for (int j = 0, _n = (numSize - 1); j < _n; j = j + 1)
if (req == sizeName[j] + "," + sizeName[j + 1]) doubleReq[j].push_back(i);
}
for (int i = 0, _n = (numSize); i < _n; i = i + 1) {
if (have[i] < singleReq[i].size()) noAnswer();
have[i] -= singleReq[i].size();
for (__typeof((singleReq[i]).begin()) it = (singleReq[i]).begin();
it != (singleReq[i]).end(); it++)
answer[*it] = sizeName[i];
}
for (int i = 0, _n = (numSize - 1); i < _n; i = i + 1) {
if (have[i] + have[i + 1] < doubleReq[i].size()) noAnswer();
for (int j = (i), _b = (i + 1); j <= _b; j = j + 1)
while (!doubleReq[i].empty() && have[j] > 0) {
have[j]--;
answer[doubleReq[i].back()] = sizeName[j];
doubleReq[i].pop_back();
}
}
cout << yes << "\n";
for (int i = (1), _b = (n); i <= _b; i = i + 1) cout << answer[i] << "\n";
}
int main(void) {
ios::sync_with_stdio(false);
cin.tie(NULL);
process();
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
You are given an array a_0, a_1, ..., a_{N-1} of length N. Process Q queries of the following types.
The type of i-th query is represented by T_i.
* T_i=1: You are given two integers X_i,V_i. Replace the value of A_{X_i} with V_i.
* T_i=2: You are given two integers L_i,R_i. Calculate the maximum value among A_{L_i},A_{L_i+1},\cdots,A_{R_i}.
* T_i=3: You are given two integers X_i,V_i. Calculate the minimum j such that X_i \leq j \leq N, V_i \leq A_j. If there is no such j, answer j=N+1 instead.
Constraints
* 1 \leq N \leq 2 \times 10^5
* 0 \leq A_i \leq 10^9
* 1 \leq Q \leq 2 \times 10^5
* 1 \leq T_i \leq 3
* 1 \leq X_i \leq N, 0 \leq V_i \leq 10^9 (T_i=1,3)
* 1 \leq L_i \leq R_i \leq N (T_i=2)
* All values in Input are integer.
Input
Input is given from Standard Input in the following format:
N Q
A_1 A_2 \cdots A_N
First query
Second query
\vdots
Q-th query
Each query is given in the following format:
If T_i=1,3,
T_i X_i V_i
If T_i=2,
T_i L_i R_i
Output
For each query with T_i=2, 3, print the answer.
Example
Input
5 5
1 2 3 2 1
2 1 5
3 2 3
1 3 1
2 2 4
3 1 3
Output
3
3
2
6
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <typename T, T (*op)(T, T), T (*e)()>
struct segtree {
segtree() : segtree(0) {}
segtree(int n) : segtree(vector<T>(n, e())) {}
segtree(vector<T> &v) : _n((int)v.size()) {
log = 0;
size = 1;
while (size < _n) {
size <<= 1;
log++;
}
d = vector<T>(2 * size, e());
for (int i = 0; i < _n; i++) {
d[size + i] = v[i];
}
for (int i = size - 1; i >= 1; i--) {
update(i);
}
}
void set(int p, T x) {
assert(0 <= p && p < _n);
p += size;
d[p] = x;
for (int i = 1; i <= log; i++) {
update(p >> i);
}
}
T prod(int l, int r) {
assert(0 <= l && l <= r && r <= _n);
T sml = e(), smr = e();
for (l += size, r += size; l < r; l >>= 1, r >>= 1) {
if ((l & 1) == 1) {
sml = op(sml, d[l++]);
}
if ((r & 1) == 1) {
smr = op(d[--r], smr);
}
}
return op(sml, smr);
}
template <bool (*f)(T)>
int max_right(int l) {
return max_right(l, [](T x) { return f(x); });
}
template <typename F>
int max_right(int l, F f) {
assert(0 <= l && l <= _n);
assert(f(e()));
if (l == _n) {
return _n;
}
l += size;
T sm = e();
do {
for (; (l & 1) == 0; l >>= 1) {
}
if (!f(op(sm, d[l]))) {
while (l < size) {
l = 2 * l;
if (f(op(sm, d[l]))) {
sm = op(sm, d[l]);
l++;
}
}
return l - size;
}
sm = op(sm, d[l]);
l++;
} while ((l & -l) != l);
return _n;
}
private:
int _n, size, log;
vector<T> d;
void update(int k) { d[k] = op(d[2 * k], d[2 * k + 1]); }
};
int op(int a, int b) { return max(a, b); }
int e() { return -1; }
int target;
bool f(int v) { return v < target; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n, q;
cin >> n >> q;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
segtree<int, op, e> seg(a);
while (q--) {
int ti;
cin >> ti;
if (ti == 1) {
int xi, vi;
cin >> xi >> vi;
xi--;
seg.set(xi, vi);
} else if (ti == 2) {
int li, ri;
cin >> li >> ri;
li--;
cout << seg.prod(li, ri) << '\n';
} else {
int xi;
cin >> xi >> target;
xi--;
cout << seg.max_right<f>(xi) + 1 << '\n';
}
}
return 0;
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
Given are two strings s and t consisting of lowercase English letters. Determine if there exists an integer i satisfying the following condition, and find the minimum such i if it exists.
* Let s' be the concatenation of 10^{100} copies of s. t is a subsequence of the string {s'}_1{s'}_2\ldots{s'}_i (the first i characters in s').
Constraints
* 1 \leq |s| \leq 10^5
* 1 \leq |t| \leq 10^5
* s and t consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
s
t
Output
If there exists an integer i satisfying the following condition, print the minimum such i; otherwise, print `-1`.
Examples
Input
contest
son
Output
10
Input
contest
programming
Output
-1
Input
contest
sentence
Output
33
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
string s, t;
vector<int> pos[26];
int main() {
ios::sync_with_stdio(false);
cin >> s >> t;
for(int i = 0; i < s.size(); i++)
pos[s[i]-'a'].push_back(i);
long long ans = 0, cur = 0;
for(int i = 0; i < t.size(); i++) {
auto& v = pos[t[i]-'a'];
auto it = lower_bound(v.begin(), v.end(), cur);
if (it != v.end()) {
cur = *it+1;
continue;
}
ans += s.size();
cur = 0;
it = lower_bound(v.begin(), v.end(), cur);
if (it != v.end())
cur = *it+1;
else {
cout << -1;
return 0;
}
}
cout << ans + cur;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
One day Vasya got hold of a sheet of checkered paper n Γ m squares in size. Our Vasya adores geometrical figures, so he painted two rectangles on the paper. The rectangles' sides are parallel to the coordinates' axes, also the length of each side of each rectangle is no less than 3 squares and the sides are painted by the grid lines. The sides can also be part of the sheet of paper's edge. Then Vasya hatched all squares on the rectangles' frames.
Let's define a rectangle's frame as the set of squares inside the rectangle that share at least one side with its border.
A little later Vasya found a sheet of paper of exactly the same size and couldn't guess whether it is the same sheet of paper or a different one. So, he asked you to check whether the sheet of paper he had found contains two painted frames and nothing besides them.
Please note that the frames painted by Vasya can arbitrarily intersect, overlap or even completely coincide.
The coordinates on the sheet of paper are introduced in such a way that the X axis goes from top to bottom, the x coordinates of the squares' numbers take values from 1 to n and the Y axis goes from the left to the right and the y coordinates of the squares' numbers take values from 1 to m.
Input
The first input line contains two integers n and m (3 β€ n, m β€ 1000) β the sizes of the sheet of paper Vasya found. Next n lines, each consisting of m symbols "." (dot) and "#" (number sign), describe the found sheet of paper. The symbol "#" represents a hatched square and the symbol "." represents a non-hatched square.
Output
In the first line print the single word "YES" or "NO", meaning whether it is true that the found sheet of paper has two frames painted on it. If the answer is positive, then print in the second line 4 integers: the coordinates of the upper left and lower right corners of the first frame. In the third line print 4 integers: the coordinates of the upper left and the lower right corners of the second frame. If there are multiple answers, print any of them.
Examples
Input
4 5
#####
#.#.#
###.#
#####
Output
YES
1 1 3 3
1 1 4 5
Input
5 6
...###
...###
#####.
#...#.
#####.
Output
NO
Note
In the first sample there are two frames on the picture. The first one is:
###..
#.#..
###..
.....
The second one is:
#####
#...#
#...#
#####
In the second sample the painted figures are not frames. Note that the height and width of valid frames is no less than 3.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0;
char ch = getchar();
bool positive = 1;
for (; ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') positive = 0;
for (; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0';
return positive ? x : -x;
}
int N, M, K, T, k, visit[1005][1005], pos[8];
char a[1005][1005];
vector<int> can[2];
inline bool paint(int x, int y) {
if (a[x][y] != '#') return 0;
if (visit[x][y] != T) ++k;
visit[x][y] = T;
return 1;
}
inline bool paint(int x1, int y1, int x2, int y2) {
if (abs(x1 - x2) < 2) return 0;
if (abs(y1 - y2) < 2) return 0;
for (int i = x1; i <= x2; ++i) {
if (!paint(i, y1)) return 0;
if (!paint(i, y2)) return 0;
}
for (int j = y1; j <= y2; ++j) {
if (!paint(x1, j)) return 0;
if (!paint(x2, j)) return 0;
}
return 1;
}
inline bool check() {
++T;
k = 0;
if (!paint(pos[0], pos[1], pos[2], pos[3])) return 0;
if (!paint(pos[4], pos[5], pos[6], pos[7])) return 0;
if (k != K) return 0;
printf("YES\n");
printf("%d %d %d %d\n%d %d %d %d\n", pos[0], pos[1], pos[2], pos[3], pos[4],
pos[5], pos[6], pos[7]);
return 1;
}
inline bool DFS(int step) {
if (step == 8) return check();
pos[step] = can[step & 1][0];
if (DFS(step + 1)) return 1;
pos[step] = can[step & 1][1];
if (DFS(step + 1)) return 1;
int size = can[step & 1].size();
pos[step] = can[step & 1][size - 1];
if (DFS(step + 1)) return 1;
pos[step] = can[step & 1][size - 2];
if (DFS(step + 1)) return 1;
return 0;
}
int main() {
N = read();
M = read();
for (int i = 1; i <= N; ++i) scanf("%s", a[i] + 1);
for (int i = 1; i <= N; ++i)
for (int j = 1; j <= M; ++j)
if (a[i][j] == '#') ++K;
for (int i = 1; i <= N; ++i)
for (int j = 2; j < M; ++j)
if (a[i][j] == '#' && a[i][j - 1] == '#' && a[i][j + 1] == '#') {
can[0].push_back(i);
break;
}
for (int j = 1; j <= M; ++j)
for (int i = 2; i < N; ++i)
if (a[i - 1][j] == '#' && a[i][j] == '#' && a[i + 1][j] == '#') {
can[1].push_back(j);
break;
}
if (can[0].size() < 2 || can[1].size() < 2 || !DFS(0)) printf("NO\n");
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
problem
You love pasta, and you make and eat pasta for dinner every day. You can make three types of pasta: tomato sauce, cream sauce, and basil sauce.
I decided to plan a dinner for N days. Choose one of the three types of pasta each day. However, if the same pasta continues, you will get bored, so do not choose the same pasta for more than 3 consecutive days. Also, the pasta for K days out of N days has already been decided.
Given the value of N and the pasta information for K days as input, create a program that finds the remainder of dividing by 10000 how many plans are to meet the conditions.
input
The input consists of K + 1 lines.
On the first line, two integers N and K (3 β€ N β€ 100, 1 β€ K β€ N) are written with a blank as a delimiter.
On the 1 + i line (1 β€ i β€ K), two integers Ai and Bi (1 β€ Ai β€ N, 1 β€ Bi β€ 3) are written with a blank as a delimiter. This means that the pasta on the Ai day has already been decided, and when Bi = 1, it is a tomato sauce, when Bi = 2, it is a cream sauce, and when Bi = 3, it is a basil sauce. Ai (1 β€ i β€ K) are all different. It is guaranteed that there will be at least one plan to meet the conditions in the given input data.
output
Divide the number of plans to satisfy the condition by 10000 and output the remainder in one line.
Input / output example
Input example 1
5 3
3 1
1 1
4 2
Output example 1
6
In I / O Example 1, you consider a 5-day schedule. The first and third days are tomato sauce, and the fourth day is cream sauce. Also, do not choose the same pasta for more than 3 consecutive days. There are six plans to meet these conditions.
1st day | 2nd day | 3rd day | 4th day | 5th day
--- | --- | --- | --- | --- | ---
Schedule 1 | 1 | 2 | 1 | 2 | 1
Schedule 2 | 1 | 2 | 1 | 2 | 2
Schedule 3 | 1 | 2 | 1 | 2 | 3
Schedule 4 | 1 | 3 | 1 | 2 | 1
Schedule 5 | 1 | 3 | 1 | 2 | 2
Schedule 6 | 1 | 3 | 1 | 2 | 3
In this table, 1 represents tomato sauce, 2 represents cream sauce, and 3 represents basil sauce.
Input example 2
20 5
10 2
4 3
12 1
13 2
9 1
Output example 2
2640
In I / O Example 2, there are a total of 4112640 plans to meet the conditions. It outputs 2640, which is the remainder of dividing it by 10000.
The question text and the data used for the automatic referee are the question text and the test data for scoring, which are created and published by the Japan Committee for Information Olympics.
Example
Input
5 3
3 1
1 1
4 2
Output
6
### Response
```cpp
#include<iostream>
#include<vector>
int n,k,v[101],dp[103][3][3];
int calc(int i,int back1,int back2){
if(i==n)return 1;
if(dp[i][back1][back2]!=0)return dp[i][back1][back2];
if(v[i]!=0){
if(back1==v[i]&&v[i]==back2)return 0;
else return calc(i+1,v[i],back1);
}else{
int ans=0;
for(int k=1;k<=3;k++){
if(k!=back1||k!=back2)ans+=calc(i+1,k,back1);
ans%=10000;
}
return dp[i][back1][back2]=ans;
}
}
int main(){
std::cin>>n>>k;
for(int i=0,a,b;i<k;i++){
std::cin>>a>>b;
v[a-1]=b;
}
std::cout<<calc(0,0,0)<<std::endl;
return 0;
}
``` |
### 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;
vector<int> alice;
vector<int> bob;
int main() {
int n, m, k;
cin >> n >> m >> k;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
alice.push_back(a);
}
for (int i = 0; i < m; i++) {
int a;
cin >> a;
bob.push_back(a);
}
sort(alice.begin(), alice.end());
sort(bob.begin(), bob.end());
for (int i = 0; i < bob.size(); i++) {
while (i != bob.size() - 1 && bob[i + 1] == bob[i]) i++;
int chan =
(upper_bound(alice.begin(), alice.end(), bob[i]) - alice.begin());
chan = alice.size() - chan;
if (chan > bob.size() - i - 1) {
cout << "YES";
return 0;
}
}
if (alice.size() > bob.size()) {
cout << "YES";
return 0;
}
cout << "NO";
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
Ziota found a video game called "Monster Invaders".
Similar to every other shooting RPG game, "Monster Invaders" involves killing monsters and bosses with guns.
For the sake of simplicity, we only consider two different types of monsters and three different types of guns.
Namely, the two types of monsters are:
* a normal monster with 1 hp.
* a boss with 2 hp.
And the three types of guns are:
* Pistol, deals 1 hp in damage to one monster, r_1 reloading time
* Laser gun, deals 1 hp in damage to all the monsters in the current level (including the boss), r_2 reloading time
* AWP, instantly kills any monster, r_3 reloading time
The guns are initially not loaded, and the Ziota can only reload 1 gun at a time.
The levels of the game can be considered as an array a_1, a_2, β¦, a_n, in which the i-th stage has a_i normal monsters and 1 boss. Due to the nature of the game, Ziota cannot use the Pistol (the first type of gun) or AWP (the third type of gun) to shoot the boss before killing all of the a_i normal monsters.
If Ziota damages the boss but does not kill it immediately, he is forced to move out of the current level to an arbitrary adjacent level (adjacent levels of level i (1 < i < n) are levels i - 1 and i + 1, the only adjacent level of level 1 is level 2, the only adjacent level of level n is level n - 1). Ziota can also choose to move to an adjacent level at any time. Each move between adjacent levels are managed by portals with d teleportation time.
In order not to disrupt the space-time continuum within the game, it is strictly forbidden to reload or shoot monsters during teleportation.
Ziota starts the game at level 1. The objective of the game is rather simple, to kill all the bosses in all the levels. He is curious about the minimum time to finish the game (assuming it takes no time to shoot the monsters with a loaded gun and Ziota has infinite ammo on all the three guns). Please help him find this value.
Input
The first line of the input contains five integers separated by single spaces: n (2 β€ n β€ 10^6) β the number of stages, r_1, r_2, r_3 (1 β€ r_1 β€ r_2 β€ r_3 β€ 10^9) β the reload time of the three guns respectively, d (1 β€ d β€ 10^9) β the time of moving between adjacent levels.
The second line of the input contains n integers separated by single spaces a_1, a_2, ..., a_n (1 β€ a_i β€ 10^6, 1 β€ i β€ n).
Output
Print one integer, the minimum time to finish the game.
Examples
Input
4 1 3 4 3
3 2 5 1
Output
34
Input
4 2 4 4 1
4 5 1 2
Output
31
Note
In the first test case, the optimal strategy is:
* Use the pistol to kill three normal monsters and AWP to kill the boss (Total time 1β
3+4=7)
* Move to stage two (Total time 7+3=10)
* Use the pistol twice and AWP to kill the boss (Total time 10+1β
2+4=16)
* Move to stage three (Total time 16+3=19)
* Use the laser gun and forced to move to either stage four or two, here we move to stage four (Total time 19+3+3=25)
* Use the pistol once, use AWP to kill the boss (Total time 25+1β
1+4=30)
* Move back to stage three (Total time 30+3=33)
* Kill the boss at stage three with the pistol (Total time 33+1=34)
Note that here, we do not finish at level n, but when all the bosses are killed.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 7;
int n;
long long a[N];
long long r1, r2, r3, d;
long long dp[N][2];
int main() {
scanf("%d %lld %lld %lld %lld", &n, &r1, &r2, &r3, &d);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
dp[1][0] = a[1] * r1 + r3;
dp[1][1] = min(r2, (a[1] + 1) * r1);
for (int i = 2; i <= n; i++) {
dp[i][0] = min(dp[i - 1][1] + 2 * d + r1 + a[i] * r1 + r3,
dp[i - 1][0] + a[i] * r1 + r3) +
d;
dp[i][0] = min(
dp[i][0], dp[i - 1][1] + 2 * r1 + 2 * d + min((a[i] + 1) * r1, r2) + d);
dp[i][1] = min(dp[i - 1][0] + min((a[i] + 1) * r1, r2),
dp[i - 1][1] + 2 * d + r1 + min((a[i] + 1) * r1, r2)) +
d;
}
long long ans = min(dp[n][0], dp[n - 1][1] + 2 * d + r1 + a[n] * r1 + r3);
printf("%lld\n", ans);
return 0;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
Let s(x) be sum of digits in decimal representation of positive integer x. Given two integers n and m, find some positive integers a and b such that
* s(a) β₯ n,
* s(b) β₯ n,
* s(a + b) β€ m.
Input
The only line of input contain two integers n and m (1 β€ n, m β€ 1129).
Output
Print two lines, one for decimal representation of a and one for decimal representation of b. Both numbers must not contain leading zeros and must have length no more than 2230.
Examples
Input
6 5
Output
6
7
Input
8 16
Output
35
53
Note
In the first sample, we have n = 6 and m = 5. One valid solution is a = 6, b = 7. Indeed, we have s(a) = 6 β₯ n and s(b) = 7 β₯ n, and also s(a + b) = s(13) = 4 β€ m.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, p = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') p = -1;
c = getchar();
}
while (c <= '9' && c >= '0') {
x = x * 10 + c - '0';
c = getchar();
}
return x * p;
}
int main() {
for (int i = 1; i <= 323; ++i) putchar('9');
putchar('\n');
for (int i = 1; i <= 323; ++i) putchar('9');
for (int i = 1; i < 323; ++i) putchar('0');
putchar('1');
putchar('\n');
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
Polycarp is working on a new operating system called BerOS. He asks you to help with implementation of a file suggestion feature.
There are n files on hard drive and their names are f_1, f_2, ..., f_n. Any file name contains between 1 and 8 characters, inclusive. All file names are unique.
The file suggestion feature handles queries, each represented by a string s. For each query s it should count number of files containing s as a substring (i.e. some continuous segment of characters in a file name equals s) and suggest any such file name.
For example, if file names are "read.me", "hosts", "ops", and "beros.18", and the query is "os", the number of matched files is 2 (two file names contain "os" as a substring) and suggested file name can be either "hosts" or "beros.18".
Input
The first line of the input contains integer n (1 β€ n β€ 10000) β the total number of files.
The following n lines contain file names, one per line. The i-th line contains f_i β the name of the i-th file. Each file name contains between 1 and 8 characters, inclusive. File names contain only lowercase Latin letters, digits and dot characters ('.'). Any sequence of valid characters can be a file name (for example, in BerOS ".", ".." and "..." are valid file names). All file names are unique.
The following line contains integer q (1 β€ q β€ 50000) β the total number of queries.
The following q lines contain queries s_1, s_2, ..., s_q, one per line. Each s_j has length between 1 and 8 characters, inclusive. It contains only lowercase Latin letters, digits and dot characters ('.').
Output
Print q lines, one per query. The j-th line should contain the response on the j-th query β two values c_j and t_j, where
* c_j is the number of matched files for the j-th query,
* t_j is the name of any file matched by the j-th query. If there is no such file, print a single character '-' instead. If there are multiple matched files, print any.
Example
Input
4
test
contests
test.
.test
6
ts
.
st.
.test
contes.
st
Output
1 contests
2 .test
1 test.
1 .test
0 -
4 test.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(0);
long long n;
cin >> n;
map<string, long long> m;
map<string, string> fi;
for (long long i = 0; i < n; i++) {
string s;
cin >> s;
set<string> ss;
for (long long j = 0; j < s.size(); j++) {
string ts;
for (long long k = j; k < s.size(); k++) {
ts += s[k];
ss.insert(ts);
}
}
for (auto j : ss) m[j]++, fi[j] = s;
}
long long q;
cin >> q;
while (q--) {
string s;
cin >> s;
if (m.count(s)) {
cout << m[s] << " " << fi[s] << "\n";
} else
cout << "0 -\n";
}
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Vasya likes taking part in Codeforces contests. When a round is over, Vasya follows all submissions in the system testing tab.
There are n solutions, the i-th of them should be tested on a_i tests, testing one solution on one test takes 1 second. The solutions are judged in the order from 1 to n. There are k testing processes which test solutions simultaneously. Each of them can test at most one solution at a time.
At any time moment t when some testing process is not judging any solution, it takes the first solution from the queue and tests it on each test in increasing order of the test ids. Let this solution have id i, then it is being tested on the first test from time moment t till time moment t + 1, then on the second test till time moment t + 2 and so on. This solution is fully tested at time moment t + a_i, and after that the testing process immediately starts testing another solution.
Consider some time moment, let there be exactly m fully tested solutions by this moment. There is a caption "System testing: d%" on the page with solutions, where d is calculated as
$$$d = round\left(100β
m/n\right),$$$
where round(x) = β{x + 0.5}β is a function which maps every real to the nearest integer.
Vasya calls a submission interesting if there is a time moment (possibly, non-integer) when the solution is being tested on some test q, and the caption says "System testing: q%". Find the number of interesting solutions.
Please note that in case when multiple processes attempt to take the first submission from the queue at the same moment (for instance, at the initial moment), the order they take the solutions does not matter.
Input
The first line contains two positive integers n and k (1 β€ n β€ 1000, 1 β€ k β€ 100) standing for the number of submissions and the number of testing processes respectively.
The second line contains n positive integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 150), where a_i is equal to the number of tests the i-th submission is to be run on.
Output
Output the only integer β the number of interesting submissions.
Examples
Input
2 2
49 100
Output
1
Input
4 2
32 100 33 1
Output
2
Input
14 5
48 19 6 9 50 20 3 42 38 43 36 21 44 6
Output
5
Note
Consider the first example. At time moment 0 both solutions start testing. At time moment 49 the first solution is fully tested, so at time moment 49.5 the second solution is being tested on the test 50, and the caption says "System testing: 50%" (because there is one fully tested solution out of two). So, the second solution is interesting.
Consider the second example. At time moment 0 the first and the second solutions start testing. At time moment 32 the first solution is fully tested, the third solution starts testing, the caption says "System testing: 25%". At time moment 32 + 24.5 = 56.5 the third solutions is being tested on test 25, the caption is still the same, thus this solution is interesting. After that the third solution is fully tested at time moment 32 + 33 = 65, the fourth solution is fully tested at time moment 65 + 1 = 66. The captions becomes "System testing: 75%", and at time moment 74.5 the second solution is being tested on test 75. So, this solution is also interesting. Overall, there are two interesting solutions.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long get_per(long long m, long long n) {
double x = 100.00 * double(m);
x /= double(n);
x = x + 0.5;
return floor(x);
}
void solve(long long tc) {
long long n, k;
cin >> n >> k;
multiset<long long> process;
for (long long i = 1; i <= k; i++) process.insert(0);
vector<array<long long, 3> > run_time(n);
vector<long long> a(n);
vector<long long> en_time(1000005);
for (long long i = 0; i < n; i++) {
cin >> a[i];
auto it = process.begin();
long long st = *it;
long long en = st + a[i];
process.erase(it);
process.insert(en);
en_time[en]++;
run_time[i] = {en, st, i};
}
sort((run_time).begin(), (run_time).end());
long long en_max = run_time[n - 1][0];
long long ans = 0;
long long cs = 0;
for (long long i = 0; i <= en_max; i++) {
cs += en_time[i];
en_time[i] = get_per(cs, n);
}
for (long long i = 0; i < n; i++) {
long long f = 0;
long long st = run_time[i][1];
long long en = run_time[i][0];
long long c_t = 1;
for (long long c = run_time[i][1]; c < run_time[i][0]; c++) {
if (en_time[c] == c_t) {
f = 1;
break;
}
c_t++;
}
ans += f;
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(0);
long long t = 1;
t = 1;
long long tc = 1;
while (t--) {
solve(tc);
tc++;
}
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
Little penguin Polo adores strings. But most of all he adores strings of length n.
One day he wanted to find a string that meets the following conditions:
1. The string consists of n lowercase English letters (that is, the string's length equals n), exactly k of these letters are distinct.
2. No two neighbouring letters of a string coincide; that is, if we represent a string as s = s1s2... sn, then the following inequality holds, si β si + 1(1 β€ i < n).
3. Among all strings that meet points 1 and 2, the required string is lexicographically smallest.
Help him find such string or state that such string doesn't exist.
String x = x1x2... xp is lexicographically less than string y = y1y2... yq, if either p < q and x1 = y1, x2 = y2, ... , xp = yp, or there is such number r (r < p, r < q), that x1 = y1, x2 = y2, ... , xr = yr and xr + 1 < yr + 1. The characters of the strings are compared by their ASCII codes.
Input
A single line contains two positive integers n and k (1 β€ n β€ 106, 1 β€ k β€ 26) β the string's length and the number of distinct letters.
Output
In a single line print the required string. If there isn't such string, print "-1" (without the quotes).
Examples
Input
7 4
Output
ababacd
Input
4 7
Output
-1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m;
int main() {
scanf("%d %d", &n, &m);
if (m > n) {
printf("-1");
return 0;
}
m -= 2;
if (n == 1) {
printf("a");
return 0;
}
if (n > 1 && m < 0) {
printf("-1");
return 0;
}
for (int i = 1; i <= n - m; i++)
if (i % 2 == 1)
printf("a");
else
printf("b");
for (int i = 1; i <= m; i++) printf("%c", char(i + 98));
printf("\n");
return 0;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
Amr bought a new video game "Guess Your Way Out!". The goal of the game is to find an exit from the maze that looks like a perfect binary tree of height h. The player is initially standing at the root of the tree and the exit from the tree is located at some leaf node.
Let's index all the leaf nodes from the left to the right from 1 to 2h. The exit is located at some node n where 1 β€ n β€ 2h, the player doesn't know where the exit is so he has to guess his way out!
Amr follows simple algorithm to choose the path. Let's consider infinite command string "LRLRLRLRL..." (consisting of alternating characters 'L' and 'R'). Amr sequentially executes the characters of the string using following rules:
* Character 'L' means "go to the left child of the current node";
* Character 'R' means "go to the right child of the current node";
* If the destination node is already visited, Amr skips current command, otherwise he moves to the destination node;
* If Amr skipped two consecutive commands, he goes back to the parent of the current node before executing next command;
* If he reached a leaf node that is not the exit, he returns to the parent of the current node;
* If he reaches an exit, the game is finished.
Now Amr wonders, if he follows this algorithm, how many nodes he is going to visit before reaching the exit?
Input
Input consists of two integers h, n (1 β€ h β€ 50, 1 β€ n β€ 2h).
Output
Output a single integer representing the number of nodes (excluding the exit node) Amr is going to visit before reaching the exit by following this algorithm.
Examples
Input
1 2
Output
2
Input
2 3
Output
5
Input
3 6
Output
10
Input
10 1024
Output
2046
Note
A perfect binary tree of height h is a binary tree consisting of h + 1 levels. Level 0 consists of a single node called root, level h consists of 2h nodes called leaves. Each node that is not a leaf has exactly two children, left and right one.
Following picture illustrates the sample test number 3. Nodes are labeled according to the order of visit.
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int h;
long long n;
int main() {
cin >> h >> n;
if (n == 1 && h == 1) {
cout << 1;
return 0;
}
long long res = 0;
bool t = 1;
long long g = 1;
stack<int> dis;
for (int i = 0; i < h; i++) {
dis.push(n % 2);
n = (n + 1) / 2;
g *= 2;
}
int d;
for (int i = 0; i < h; i++) {
d = dis.top();
dis.pop();
if (t != d) {
res += g;
} else {
res += 1;
}
g /= 2;
t = !d;
}
cout << res;
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Note that the only differences between easy and hard versions are the constraints on n and the time limit. You can make hacks only if all versions are solved.
Slime is interested in sequences. He defined good positive integer sequences p of length n as follows:
* For each k>1 that presents in p, there should be at least one pair of indices i,j, such that 1 β€ i < j β€ n, p_i = k - 1 and p_j = k.
For the given integer n, the set of all good sequences of length n is s_n. For the fixed integer k and the sequence p, let f_p(k) be the number of times that k appears in p. For each k from 1 to n, Slime wants to know the following value:
$$$\left(β_{pβ s_n} f_p(k)\right)\ mod\ 998 244 353$$$
Input
The first line contains one integer n\ (1β€ nβ€ 5000).
Output
Print n integers, the i-th of them should be equal to \left(β_{pβ s_n} f_p(i)\right)\ mod\ 998 244 353.
Examples
Input
2
Output
3 1
Input
3
Output
10 7 1
Input
1
Output
1
Note
In the first example, s=\{[1,1],[1,2]\}.
In the second example, s=\{[1,1,1],[1,1,2],[1,2,1],[1,2,2],[2,1,2],[1,2,3]\}.
In the third example, s=\{[1]\}.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
int n, e[5001][5001];
int fac[5001], ifac[5001];
long long ans;
inline int add(int x, int y) { return x + y < mod ? x + y : x + y - mod; }
inline int power(int a, int n) {
int tp = 1;
while (n) {
if (n & 1) tp = 1ll * tp * a % mod;
a = 1ll * a * a % mod, n >>= 1;
}
return tp;
}
int main() {
cin >> n;
fac[0] = 1;
for (int i = 1; i <= n; i++) {
fac[i] = 1ll * fac[i - 1] * i % mod, e[i][0] = 1;
for (int j = 1; j < i; j++)
e[i][j] =
(1ll * (i - j) * e[i - 1][j - 1] + 1ll * (j + 1) * e[i - 1][j]) % mod;
}
ifac[n] = power(fac[n], mod - 2);
for (int i = n - 1; ~i; i--) ifac[i] = 1ll * ifac[i + 1] * (i + 1) % mod;
for (int i = 1; i <= n; i++) {
ans = 0;
for (int j = i; j <= n; j++) ans += 1ll * e[j][i - 1] * ifac[j], ans %= mod;
printf("%lld%c", ans * fac[n] % mod, " \n"[i == n]);
}
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
There are 2^N players, numbered 1, 2, ..., 2^N. They decided to hold a tournament.
The tournament proceeds as follows:
* Choose a permutation of 1, 2, ..., 2^N: p_1, p_2, ..., p_{2^N}.
* The players stand in a row in the order of Player p_1, Player p_2, ..., Player p_{2^N}.
* Repeat the following until there is only one player remaining in the row:
* Play the following matches: the first player in the row versus the second player in the row, the third player versus the fourth player, and so on. The players who lose leave the row. The players who win stand in a row again, preserving the relative order of the players.
* The last player who remains in the row is the champion.
It is known that, the result of the match between two players can be written as follows, using M integers A_1, A_2, ..., A_M given as input:
* When y = A_i for some i, the winner of the match between Player 1 and Player y (2 \leq y \leq 2^N) will be Player y.
* When y \neq A_i for every i, the winner of the match between Player 1 and Player y (2 \leq y \leq 2^N) will be Player 1.
* When 2 \leq x < y \leq 2^N, the winner of the match between Player x and Player y will be Player x.
The champion of this tournament depends only on the permutation p_1, p_2, ..., p_{2^N} chosen at the beginning. Find the number of permutation p_1, p_2, ..., p_{2^N} chosen at the beginning of the tournament that would result in Player 1 becoming the champion, modulo 10^9 + 7.
Constraints
* 1 \leq N \leq 16
* 0 \leq M \leq 16
* 2 \leq A_i \leq 2^N (1 \leq i \leq M)
* A_i < A_{i + 1} (1 \leq i < M)
Input
Input is given from Standard Input in the following format:
N M
A_1 A_2 ... A_M
Output
Print the answer.
Examples
Input
2 1
3
Output
8
Input
4 3
2 4 6
Output
0
Input
3 0
Output
40320
Input
3 3
3 4 7
Output
2688
Input
16 16
5489 5490 5491 5492 5493 5494 5495 5497 18993 18995 18997 18999 19000 19001 19002 19003
Output
816646464
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n,m;
int seq[17];
int dp[18][262144];
const int mod = 1000000007;
int fact[500000],inv[500000];
int qpow(int base,int tms)
{
int tmp = 1;
while(tms)
{
if(tms & 1) tmp = tmp * 1ll * base % mod;
base = base * 1ll * base % mod;
tms >>= 1;
}
return tmp;
}
int C(int n,int r)
{
if(n < r) return 0;
return fact[n] * 1ll * inv[n - r] % mod;
}
bool cmp(int a,int b)
{
return a > b;
}
int main()
{
fact[0] = inv[0] = 1;
for(int i = 1;i <= 400000; ++ i)
fact[i] = fact[i - 1] * 1ll * i % mod;
inv[400000] = qpow(fact[400000],mod - 2);
for(int i = 399999;i >= 1; -- i)
inv[i] = inv[i + 1] * 1ll * (i + 1) % mod;
scanf("%d%d",&n,&m);
int all = (1 << n) - 1;
dp[1][0] = 1;
for(int i = 1;i <= m; ++ i)
scanf("%d",&seq[i]);
sort(seq + 1,seq + 1 + m,cmp);
for(int i = 1;i <= m; ++ i)
for(int j = 0;j <= all; ++ j)
if(dp[i][j])
{
dp[i + 1][j] = (dp[i + 1][j] + dp[i][j]) % mod;
int lef = (1 << n) - j - seq[i];
for(int k = 1;k <= n; ++ k)
if(!(j & 1 << k - 1))
dp[i + 1][j | 1 << k - 1] = (dp[i + 1][j | 1 << k - 1] + dp[i][j] * 1ll * C(lef,(1 << k - 1) - 1) % mod * (1 << k - 1) % mod) % mod;
}
int as = 0;
for(int i = 0;i <= all; ++ i)
{
int cur = dp[m + 1][i] * 1ll * fact[(1 << n) - i - 1] % mod;
if(__builtin_popcount(i) & 1) as = (as - cur + mod) % mod;
else as = (as + cur) % mod;
}
printf("%d\n",as * 1ll * (1 << n) % mod);
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
There are N cards placed on a grid with H rows and W columns of squares.
The i-th card has an integer A_i written on it, and it is placed on the square at the R_i-th row from the top and the C_i-th column from the left.
Multiple cards may be placed on the same square.
You will first pick up at most one card from each row.
Then, you will pick up at most one card from each column.
Find the maximum possible sum of the integers written on the picked cards.
Constraints
* All values are integers.
* 1 \leq N \leq 10^5
* 1 \leq H, W \leq 10^5
* 1 \leq A_i \leq 10^5
* 1 \leq R_i \leq H
* 1 \leq C_i \leq W
Input
Input is given from Standard Input in the following format:
N H W
R_1 C_1 A_1
R_2 C_2 A_2
\vdots
R_N C_N A_N
Output
Print the maximum possible sum of the integers written on the picked cards.
Examples
Input
6 2 2
2 2 2
1 1 8
1 1 5
1 2 9
1 2 7
2 1 4
Output
28
Input
13 5 6
1 3 35902
4 6 19698
4 6 73389
3 6 3031
3 1 4771
1 4 4784
2 1 36357
2 1 24830
5 6 50219
4 6 22645
1 2 30739
1 4 68417
1 5 78537
Output
430590
Input
1 100000 100000
1 1 1
Output
1
### Response
```cpp
#include <iostream>
#include <algorithm>
#include <numeric>
#include <vector>
#include <tuple>
struct UnionFind {
std::vector<int> par, sz;
std::vector<bool> namori;
int gnum;
explicit UnionFind(int n)
: par(n), sz(n, 1), namori(n, false), gnum(n) {
std::iota(par.begin(), par.end(), 0);
}
int find(int v) {
return (par[v] == v) ? v : (par[v] = find(par[v]));
}
void unite(int u, int v) {
u = find(u), v = find(v);
if (u == v) return;
if (sz[u] < sz[v]) std::swap(u, v);
sz[u] += sz[v];
par[v] = u;
namori[u] = (namori[u] || namori[v]);
--gnum;
}
bool same(int u, int v) { return find(u) == find(v); }
bool ispar(int v) { return v == find(v); }
int size(int v) { return sz[find(v)]; }
};
using lint = long long;
void solve() {
int n, h, w;
std::cin >> n >> h >> w;
std::vector<std::tuple<lint, int, int>> es;
while (n--) {
int x, y;
lint a;
std::cin >> x >> y >> a;
--x, --y;
es.emplace_back(a, x, y + h);
}
std::sort(es.rbegin(), es.rend());
UnionFind uf(h + w);
lint ans = 0;
for (auto e : es) {
int u, v;
lint a;
std::tie(a, u, v) = e;
u = uf.find(u);
v = uf.find(v);
if (u == v) {
if (uf.namori[u]) continue;
ans += a;
uf.namori[u] = true;
} else {
if (uf.namori[u] && uf.namori[v]) continue;
ans += a;
uf.unite(u, v);
}
}
std::cout << ans << std::endl;
}
int main() {
std::cin.tie(nullptr);
std::cout.tie(nullptr);
std::ios::sync_with_stdio(false);
solve();
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Little W and Little P decided to send letters to each other regarding the most important events during a day. There are n events during a day: at time moment t_i something happens to the person p_i (p_i is either W or P, denoting Little W and Little P, respectively), so he needs to immediately send a letter to the other person. They can send a letter using one of the two ways:
* Ask Friendly O to deliver the letter directly. Friendly O takes d acorns for each letter.
* Leave the letter at Wise R's den. Wise R values free space, so he takes c β
T acorns for storing a letter for a time segment of length T. The recipient can take a letter from Wise R either when he leaves his own letter at Wise R's den, or at time moment t_{n + 1}, when everybody comes to Wise R for a tea. It is not possible to take a letter from Wise R's den at other time moments. The friends can store as many letters at Wise R's den as they want, paying for each one separately.
Help the friends determine the minimum possible total cost of sending all letters.
Input
The first line contains three integers n, c, d (1 β€ n β€ 10^5, 1 β€ c β€ 10^2, 1 β€ d β€ 10^8) β the number of letters, the cost of storing a letter for one time unit at Wise R's den and the cost of delivering a letter via Friendly O.
The next n describe the events. The i-th of them contains an integer t_i and a character p_i (0 β€ t_i β€ 10^6, p_i is either W or P) β the time the i-th event happens and the person the event happens to.
The last line contains a single integer t_{n + 1} (0 β€ t_{n+1} β€ 10^6) β the time when everybody comes to Wise R for a tea and takes all remaining letters.
It is guaranteed that t_i < t_{i + 1} for all i from 1 to n.
Output
Print a single integer β the minimum possible cost of delivery of all letters.
Examples
Input
5 1 4
0 P
1 W
3 P
5 P
8 P
10
Output
16
Input
10 10 94
17 W
20 W
28 W
48 W
51 P
52 W
56 W
62 P
75 P
78 P
87
Output
916
Note
One of optimal solutions in the first example:
* At time moment 0 Little P leaves the letter at Wise R's den.
* At time moment 1 Little W leaves his letter at Wise R's den and takes Little P's letter. This letter is at the den from time moment 0 to time moment 1, it costs 1 acorn.
* At time moment 3 Little P sends his letter via Friendly O, it costs 4 acorns.
* At time moment 5 Little P leaves his letter at the den, receiving Little W's letter which storage costs 4 acorns.
* At time moment 8 Little P leaves one more letter at the den.
* At time moment 10 Little W comes to the den for a tea and receives the two letters, paying 5 and 2 acorns.
The total cost of delivery is thus 1 + 4 + 4 + 5 + 2 = 16 acorns.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1000000000000000000ll;
int n, c, d, a[100101], p[100010];
long long f[2], g[2], nw;
char s[5];
int main() {
scanf("%d%d%d", &n, &c, &d);
for (int i = 1; i <= n; i++) scanf("%d%s", &a[i], s), p[i] = (s[0] == 'P');
scanf("%d", &a[n + 1]), f[0] = 0, f[1] = inf;
for (int i = 1; i <= n; i++) {
int l = i;
while (i < n && p[i + 1] == p[i]) i++;
g[0] = f[0] + 1ll * d * (i - l + 1);
nw = g[1] = f[1] + 1ll * c * (a[i + 1] - a[l]) + 1ll * d * (i - l);
for (int j = 1; j <= i - l; j++)
nw += 1ll * c * (a[i + 1] - a[i - j + 1]) - d, g[1] = min(g[1], nw);
nw = f[0] + 1ll * d * (i - l + 1);
for (int j = 1; j <= i - l + 1; j++)
nw += 1ll * c * (a[i + 1] - a[i - j + 1]) - d, g[1] = min(g[1], nw);
f[0] = g[0], f[1] = g[1];
}
printf("%I64d\n", min(f[0], f[1]));
return 0;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
You've got a rectangular table with length a and width b and the infinite number of plates of radius r. Two players play the following game: they take turns to put the plates on the table so that the plates don't lie on each other (but they can touch each other), and so that any point on any plate is located within the table's border. During the game one cannot move the plates that already lie on the table. The player who cannot make another move loses. Determine which player wins, the one who moves first or the one who moves second, provided that both players play optimally well.
Input
A single line contains three space-separated integers a, b, r (1 β€ a, b, r β€ 100) β the table sides and the plates' radius, correspondingly.
Output
If wins the player who moves first, print "First" (without the quotes). Otherwise print "Second" (without the quotes).
Examples
Input
5 5 2
Output
First
Input
6 7 4
Output
Second
Note
In the first sample the table has place for only one plate. The first player puts a plate on the table, the second player can't do that and loses.
<image>
In the second sample the table is so small that it doesn't have enough place even for one plate. So the first player loses without making a single move.
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int l, b, r;
cin >> l >> b >> r;
if (min(l, b) < 2 * r)
cout << "Second" << endl;
else
cout << "First" << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
clock_t zzzz = clock();
long long int t;
t = 1;
while (t--) solve();
fprintf(stderr, "Total Time: %.3f\n",
(double)(clock() - zzzz) / CLOCKS_PER_SEC),
fflush(stderr);
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
We saw the little game Marmot made for Mole's lunch. Now it's Marmot's dinner time and, as we all know, Marmot eats flowers. At every dinner he eats some red and white flowers. Therefore a dinner can be represented as a sequence of several flowers, some of them white and some of them red.
But, for a dinner to be tasty, there is a rule: Marmot wants to eat white flowers only in groups of size k.
Now Marmot wonders in how many ways he can eat between a and b flowers. As the number of ways could be very large, print it modulo 1000000007 (109 + 7).
Input
Input contains several test cases.
The first line contains two integers t and k (1 β€ t, k β€ 105), where t represents the number of test cases.
The next t lines contain two integers ai and bi (1 β€ ai β€ bi β€ 105), describing the i-th test.
Output
Print t lines to the standard output. The i-th line should contain the number of ways in which Marmot can eat between ai and bi flowers at dinner modulo 1000000007 (109 + 7).
Examples
Input
3 2
1 3
2 3
4 4
Output
6
5
5
Note
* For K = 2 and length 1 Marmot can eat (R).
* For K = 2 and length 2 Marmot can eat (RR) and (WW).
* For K = 2 and length 3 Marmot can eat (RRR), (RWW) and (WWR).
* For K = 2 and length 4 Marmot can eat, for example, (WWWW) or (RWWR), but for example he can't eat (WWWR).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long t, k;
cin >> t >> k;
vector<long long> dp = vector<long long>(100002, 1);
for (long long i = 1; i < 100002; i++) {
dp[i] = dp[i - 1] % 1000000007;
if (i >= k) {
dp[i] = (dp[i] + dp[i - k]) % 1000000007;
}
}
for (long long i = 1; i < 100002; i++) {
dp[i] = (dp[i] + dp[i - 1]) % 1000000007;
}
for (long long i = 0; i < t; i++) {
long long a, b;
cin >> a >> b;
cout << (dp[b] + 1000000007 - dp[a - 1]) % 1000000007 << "\n";
}
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
Inna and Dima bought a table of size n Γ m in the shop. Each cell of the table contains a single letter: "D", "I", "M", "A".
Inna loves Dima, so she wants to go through his name as many times as possible as she moves through the table. For that, Inna acts as follows:
1. initially, Inna chooses some cell of the table where letter "D" is written;
2. then Inna can move to some side-adjacent table cell that contains letter "I"; then from this cell she can go to one of the side-adjacent table cells that contains the written letter "M"; then she can go to a side-adjacent cell that contains letter "A". Then Inna assumes that she has gone through her sweetheart's name;
3. Inna's next move can be going to one of the side-adjacent table cells that contains letter "D" and then walk on through name DIMA in the similar manner. Inna never skips a letter. So, from the letter "D" she always goes to the letter "I", from the letter "I" she always goes the to letter "M", from the letter "M" she always goes to the letter "A", and from the letter "A" she always goes to the letter "D".
Depending on the choice of the initial table cell, Inna can go through name DIMA either an infinite number of times or some positive finite number of times or she can't go through his name once. Help Inna find out what maximum number of times she can go through name DIMA.
Input
The first line of the input contains two integers n and m (1 β€ n, m β€ 103).
Then follow n lines that describe Inna and Dima's table. Each line contains m characters. Each character is one of the following four characters: "D", "I", "M", "A".
Note that it is not guaranteed that the table contains at least one letter "D".
Output
If Inna cannot go through name DIMA once, print on a single line "Poor Dima!" without the quotes. If there is the infinite number of names DIMA Inna can go through, print "Poor Inna!" without the quotes. Otherwise print a single integer β the maximum number of times Inna can go through name DIMA.
Examples
Input
1 2
DI
Output
Poor Dima!
Input
2 2
MA
ID
Output
Poor Inna!
Input
5 5
DIMAD
DIMAI
DIMAM
DDMAA
AAMID
Output
4
Note
Notes to the samples:
In the first test sample, Inna cannot go through name DIMA a single time.
In the second test sample, Inna can go through the infinite number of words DIMA. For that, she should move in the clockwise direction starting from the lower right corner.
In the third test sample the best strategy is to start from the cell in the upper left corner of the table. Starting from this cell, Inna can go through name DIMA four times.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int INF = 2000 * 1000 * 1000;
const int mod = 1000 * 1000 * 1000 + 7;
const int maxn = 1100;
int n, m, sz, ans, dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0}, dp[maxn][maxn],
used[maxn][maxn];
char a[maxn][maxn];
pair<int, int> b[maxn * maxn];
bool check(int x, int y, int u, int v) {
if (a[x][y] == 'D' && a[u][v] == 'I') return true;
if (a[x][y] == 'I' && a[u][v] == 'M') return true;
if (a[x][y] == 'M' && a[u][v] == 'A') return true;
if (a[x][y] == 'A' && a[u][v] == 'D') return true;
return false;
}
void dfs(int x, int y) {
used[x][y] = 1;
dp[x][y] = 0;
if (a[x][y] == 'A') dp[x][y] = 1;
for (int i = 0; i < 4; ++i)
if (x + dx[i] > 0 && x + dx[i] <= n && y + dy[i] > 0 && y + dy[i] <= m) {
if (!check(x, y, x + dx[i], y + dy[i])) continue;
if (used[x + dx[i]][y + dy[i]] == 1) {
cout << "Poor Inna!";
exit(0);
}
if (!used[x + dx[i]][y + dy[i]]) dfs(x + dx[i], y + dy[i]);
dp[x][y] = max(dp[x][y], dp[x + dx[i]][y + dy[i]] + (a[x][y] == 'A'));
}
used[x][y] = 2;
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) {
cin >> a[i][j];
if (a[i][j] == 'D') b[sz++] = make_pair(i, j);
}
for (int i = 0; i < sz; ++i) {
if (!used[b[i].first][b[i].second]) dfs(b[i].first, b[i].second);
ans = max(ans, dp[b[i].first][b[i].second]);
}
if (!ans)
cout << "Poor Dima!";
else
cout << ans;
return 0;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
You are given an integer N.
For two positive integers A and B, we will define F(A,B) as the larger of the following: the number of digits in the decimal notation of A, and the number of digits in the decimal notation of B.
For example, F(3,11) = 2 since 3 has one digit and 11 has two digits.
Find the minimum value of F(A,B) as (A,B) ranges over all pairs of positive integers such that N = A \times B.
Constraints
* 1 \leq N \leq 10^{10}
* N is an integer.
Input
The input is given from Standard Input in the following format:
N
Output
Print the minimum value of F(A,B) as (A,B) ranges over all pairs of positive integers such that N = A \times B.
Examples
Input
10000
Output
3
Input
1000003
Output
7
Input
9876543210
Output
6
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int ws(int n){
int l=0;
while(n) n/=10,l++;
return l;
}
int f(long long n){
for(int i=(int)sqrt(n);;i--)
if(n%i==0)
return n/i;
}
int main(){
long long n;
scanf("%lld",&n);
printf("%d\n",ws(f(n)));
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
Parmida is a clever girl and she wants to participate in Olympiads this year. Of course she wants her partner to be clever too (although he's not)! Parmida has prepared the following test problem for Pashmak.
There is a sequence a that consists of n integers a1, a2, ..., an. Let's denote f(l, r, x) the number of indices k such that: l β€ k β€ r and ak = x. His task is to calculate the number of pairs of indicies i, j (1 β€ i < j β€ n) such that f(1, i, ai) > f(j, n, aj).
Help Pashmak with the test.
Input
The first line of the input contains an integer n (1 β€ n β€ 106). The second line contains n space-separated integers a1, a2, ..., an (1 β€ ai β€ 109).
Output
Print a single integer β the answer to the problem.
Examples
Input
7
1 2 1 1 2 2 1
Output
8
Input
3
1 1 1
Output
1
Input
5
1 2 3 4 5
Output
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
int l[N], v[N], r[N];
int seg[4 * N];
map<int, int> ls, rs;
void update(int n, int l, int r, int s, int e, int d) {
if (r < s || l > e) return;
if (l >= s && r <= e) {
seg[n] += d;
return;
}
int mid = (l + r) / 2;
update(n * 2 + 1, l, mid, s, e, d);
update(n * 2 + 2, mid + 1, r, s, e, d);
seg[n] = seg[n * 2 + 1] + seg[n * 2 + 2];
}
int get(int n, int l, int r, int s, int e) {
if (r < s || l > e) return 0;
if (l >= s && r <= e) {
return seg[n];
}
int mid = (l + r) / 2;
return get(n * 2 + 1, l, mid, s, e) + get(n * 2 + 2, mid + 1, r, s, e);
}
int main() {
int n;
scanf("%d", &n);
vector<int> cmp;
for (int i = 0; i < n; i++) {
scanf("%d", &v[i]);
cmp.push_back(v[i]);
}
sort(cmp.begin(), cmp.end());
cmp.resize(unique(cmp.begin(), cmp.end()) - cmp.begin());
for (int i = 0; i < n; i++) {
v[i] = lower_bound(cmp.begin(), cmp.end(), v[i]) - cmp.begin();
}
for (int i = 0; i < n; i++) {
ls[v[i]]++;
l[i] = ls[v[i]];
}
long long ans = 0;
for (int i = n - 1; i >= 0; i--) {
ans += get(0, 0, N, 0, l[i] - 1);
rs[v[i]]++;
r[i] = rs[v[i]];
update(0, 0, N, r[i], r[i], 1);
}
cout << ans << endl;
return 0;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
Kevin Sun wants to move his precious collection of n cowbells from Naperthrill to Exeter, where there is actually grass instead of corn. Before moving, he must pack his cowbells into k boxes of a fixed size. In order to keep his collection safe during transportation, he won't place more than two cowbells into a single box. Since Kevin wishes to minimize expenses, he is curious about the smallest size box he can use to pack his entire collection.
Kevin is a meticulous cowbell collector and knows that the size of his i-th (1 β€ i β€ n) cowbell is an integer si. In fact, he keeps his cowbells sorted by size, so si - 1 β€ si for any i > 1. Also an expert packer, Kevin can fit one or two cowbells into a box of size s if and only if the sum of their sizes does not exceed s. Given this information, help Kevin determine the smallest s for which it is possible to put all of his cowbells into k boxes of size s.
Input
The first line of the input contains two space-separated integers n and k (1 β€ n β€ 2Β·k β€ 100 000), denoting the number of cowbells and the number of boxes, respectively.
The next line contains n space-separated integers s1, s2, ..., sn (1 β€ s1 β€ s2 β€ ... β€ sn β€ 1 000 000), the sizes of Kevin's cowbells. It is guaranteed that the sizes si are given in non-decreasing order.
Output
Print a single integer, the smallest s for which it is possible for Kevin to put all of his cowbells into k boxes of size s.
Examples
Input
2 1
2 5
Output
7
Input
4 3
2 3 5 9
Output
9
Input
3 2
3 5 7
Output
8
Note
In the first sample, Kevin must pack his two cowbells into the same box.
In the second sample, Kevin can pack together the following sets of cowbells: {2, 3}, {5} and {9}.
In the third sample, the optimal solution is {3, 5} and {7}.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
long long a[n];
for (long long i = 0; i < n; i++) cin >> a[i];
long long _max = a[n - 1];
for (long long i = 0; i < n - k; i++)
_max = max(_max, a[i] + a[2 * (n - k) - i - 1]);
cout << _max;
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Programmers working on a large project have just received a task to write exactly m lines of code. There are n programmers working on a project, the i-th of them makes exactly ai bugs in every line of code that he writes.
Let's call a sequence of non-negative integers v1, v2, ..., vn a plan, if v1 + v2 + ... + vn = m. The programmers follow the plan like that: in the beginning the first programmer writes the first v1 lines of the given task, then the second programmer writes v2 more lines of the given task, and so on. In the end, the last programmer writes the remaining lines of the code. Let's call a plan good, if all the written lines of the task contain at most b bugs in total.
Your task is to determine how many distinct good plans are there. As the number of plans can be large, print the remainder of this number modulo given positive integer mod.
Input
The first line contains four integers n, m, b, mod (1 β€ n, m β€ 500, 0 β€ b β€ 500; 1 β€ mod β€ 109 + 7) β the number of programmers, the number of lines of code in the task, the maximum total number of bugs respectively and the modulo you should use when printing the answer.
The next line contains n space-separated integers a1, a2, ..., an (0 β€ ai β€ 500) β the number of bugs per line for each programmer.
Output
Print a single integer β the answer to the problem modulo mod.
Examples
Input
3 3 3 100
1 1 1
Output
10
Input
3 6 5 1000000007
1 2 3
Output
0
Input
3 5 6 11
1 2 1
Output
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m, b, mod, ans = 0;
int dp[505][505];
int main() {
cin >> n >> m >> b >> mod;
dp[0][0] = 1;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
for (int j = 1; j <= m; j++) {
for (int k = x; k <= b; k++) (dp[j][k] += dp[j - 1][k - x]) %= mod;
}
}
for (int i = 0; i <= b; i++) {
(ans += dp[m][i]) %= mod;
}
cout << ans << endl;
return 0;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
Theater stage is a rectangular field of size n Γ m. The director gave you the stage's plan which actors will follow. For each cell it is stated in the plan if there would be an actor in this cell or not.
You are to place a spotlight on the stage in some good position. The spotlight will project light in one of the four directions (if you look at the stage from above) β left, right, up or down. Thus, the spotlight's position is a cell it is placed to and a direction it shines.
A position is good if two conditions hold:
* there is no actor in the cell the spotlight is placed to;
* there is at least one actor in the direction the spotlight projects.
Count the number of good positions for placing the spotlight. Two positions of spotlight are considered to be different if the location cells or projection direction differ.
Input
The first line contains two positive integers n and m (1 β€ n, m β€ 1000) β the number of rows and the number of columns in the plan.
The next n lines contain m integers, 0 or 1 each β the description of the plan. Integer 1, means there will be an actor in the corresponding cell, while 0 means the cell will remain empty. It is guaranteed that there is at least one actor in the plan.
Output
Print one integer β the number of good positions for placing the spotlight.
Examples
Input
2 4
0 1 0 0
1 0 1 0
Output
9
Input
4 4
0 0 0 0
1 0 0 1
0 1 1 0
0 1 0 0
Output
20
Note
In the first example the following positions are good:
1. the (1, 1) cell and right direction;
2. the (1, 1) cell and down direction;
3. the (1, 3) cell and left direction;
4. the (1, 3) cell and down direction;
5. the (1, 4) cell and left direction;
6. the (2, 2) cell and left direction;
7. the (2, 2) cell and up direction;
8. the (2, 2) and right direction;
9. the (2, 4) cell and left direction.
Therefore, there are 9 good positions in this example.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int a[1010][1010], co[1010][1010], st[1010][1010];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
scanf("%d", &a[i][j]);
st[i][j] = a[i][j];
co[i][j] = a[i][j];
if (i > 0) co[i][j] += co[i - 1][j];
if (j > 0) st[i][j] += st[i][j - 1];
}
}
int ans = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (a[i][j] == 0) {
if (co[n - 1][j] - co[i][j] > 0) ans++;
if (co[i][j] > 0) ans++;
if (st[i][j] > 0) ans++;
if (st[i][m - 1] - st[i][j] > 0) ans++;
}
}
}
cout << ans;
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
Barney was hanging out with Nora for a while and now he thinks he may have feelings for her. Barney wants to send her a cheesy text message and wants to make her as happy as possible.
<image>
Initially, happiness level of Nora is 0. Nora loves some pickup lines like "I'm falling for you" and stuff. Totally, she knows n pickup lines, each consisting only of lowercase English letters, also some of them may be equal (in writing, but different in pronouncing or meaning though). Every time Nora sees i-th pickup line as a consecutive subsequence of Barney's text message her happiness level increases by ai. These substrings may overlap, for example, Nora will see the pickup line aa twice and the pickup line ab once in text message aaab.
Due to texting app limits, Barney's text may have up to l characters.
Barney asked you to help him make Nora as much happy as possible, it's gonna be legen...
Input
The first line of input contains two integers n and l (1 β€ n β€ 200, 1 β€ l β€ 1014) β the number of pickup lines and the maximum length of Barney's text.
The second line contains n integers a1, a2, ..., an (1 β€ ai β€ 100), meaning that Nora's happiness level increases by ai after every time seeing i-th pickup line.
The next n lines contain the pickup lines. i-th of them contains a single string si consisting of only English lowercase letter. Summary length of all pickup lines does not exceed 200.
All strings are not empty.
Output
Print the only integer β the maximum possible value of Nora's happiness level after reading Barney's text.
Examples
Input
3 6
3 2 1
heart
earth
art
Output
6
Input
3 6
3 2 8
heart
earth
art
Output
16
Note
An optimal answer for the first sample case is hearth containing each pickup line exactly once.
An optimal answer for the second sample case is artart.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long N = 205;
long long n, m, tot, val[N], h[N], ch[N][26], fail[N], v, i, ans, cur, u, j, c,
len;
char a[N];
struct w {
long long c[N][N];
w() {
for (long long i = 0; i < N; i++)
for (long long j = 0; j < N; j++) c[i][j] = -1e18;
}
w operator*(w x) {
w res;
for (long long k = 0; k <= tot; k++)
for (long long i = 0; i <= tot; i++)
for (long long j = 0; j <= tot; j++)
res.c[i][j] = max(res.c[i][j], c[i][k] + x.c[k][j]);
return res;
}
} k;
w pow(w x, long long y) {
w res;
for (long long i = 0; i <= tot; ++i) res.c[i][i] = 0;
while (y) {
if (y & 1) res = res * x;
x = x * x;
y >>= 1;
}
return res;
}
int main() {
scanf("%d%lld", &n, &m);
for (i = 1; i <= n; ++i) scanf("%d", &val[i]);
for (i = 1; i <= n; ++i) {
scanf("%s", a + 1);
cur = 0;
len = strlen(a + 1);
for (long long j = 1; j <= len; j++) {
c = a[j] - 'a';
if (!ch[cur][c]) ch[cur][c] = ++tot;
cur = ch[cur][c];
}
h[cur] += val[i];
}
deque<long long> q;
for (i = 0; i < 26; ++i) {
v = ch[0][i];
if (v) q.push_back(v);
}
while (!q.empty()) {
u = q.front();
q.pop_front();
h[u] += h[fail[u]];
for (i = 0; i < 26; ++i) {
v = ch[u][i];
if (v)
fail[v] = ch[fail[u]][i], q.push_back(v);
else
ch[u][i] = ch[fail[u]][i];
}
}
for (i = 0; i <= tot; ++i)
for (j = 0; j < 26; ++j) cur = ch[i][j], k.c[i][cur] = h[cur];
k = pow(k, m);
for (long long i = 0; i <= tot; ++i) ans = max(ans, k.c[0][i]);
printf("%lld", ans);
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
Vasya, like many others, likes to participate in a variety of sweepstakes and lotteries. Now he collects wrappings from a famous chocolate bar "Jupiter". According to the sweepstake rules, each wrapping has an integer written on it β the number of points that the participant adds to his score as he buys the bar. After a participant earns a certain number of points, he can come to the prize distribution center and exchange the points for prizes. When somebody takes a prize, the prize's cost is simply subtracted from the number of his points.
Vasya didn't only bought the bars, he also kept a record of how many points each wrapping cost. Also, he remembers that he always stucks to the greedy strategy β as soon as he could take at least one prize, he went to the prize distribution centre and exchanged the points for prizes. Moreover, if he could choose between multiple prizes, he chose the most expensive one. If after an exchange Vasya had enough points left to get at least one more prize, then he continued to exchange points.
The sweepstake has the following prizes (the prizes are sorted by increasing of their cost):
* a mug (costs a points),
* a towel (costs b points),
* a bag (costs c points),
* a bicycle (costs d points),
* a car (costs e points).
Now Vasya wants to recollect what prizes he has received. You know sequence p1, p2, ..., pn, where pi is the number of points Vasya got for the i-th bar. The sequence of points is given in the chronological order. You also know numbers a, b, c, d, e. Your task is to find, how many prizes Vasya received, what prizes they are and how many points he's got left after all operations are completed.
Input
The first line contains a single integer n (1 β€ n β€ 50) β the number of chocolate bar wrappings that brought points to Vasya. The second line contains space-separated integers p1, p2, ..., pn (1 β€ pi β€ 109). The third line contains 5 integers a, b, c, d, e (1 β€ a < b < c < d < e β€ 109) β the prizes' costs.
Output
Print on the first line 5 integers, separated by a space β the number of mugs, towels, bags, bicycles and cars that Vasya has got, respectively. On the second line print a single integer β the number of points Vasya will have left after all operations of exchange are completed.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
3
3 10 4
2 4 10 15 20
Output
1 1 1 0 0
1
Input
4
10 4 39 2
3 5 10 11 12
Output
3 0 1 0 3
0
Note
In the first sample Vasya gets 3 points after eating the first chocolate bar. Then he exchanges 2 points and gets a mug. Vasya wins a bag after eating the second chocolate bar. Then he wins a towel after eating the third chocolate bar. After all chocolate bars 3 - 2 + 10 - 10 + 4 - 4 = 1 points remains.
### Response
```cpp
#include <bits/stdc++.h>
struct compare {
bool operator()(const int& l, const int& r) { return l > r; }
};
using namespace std;
priority_queue<int, vector<int>, compare> pq;
long long ans[5];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
long long arr[n], c[5];
for (int i = 0; i < n; i++) cin >> arr[i];
for (int i = 0; i < 5; i++) cin >> c[i];
long long tot = 0;
for (int i = 0; i < n; i++) {
tot += arr[i];
if (tot < c[0]) continue;
int itr = 0;
while (itr < 5 && c[itr] <= tot) itr++;
itr--;
for (; itr >= 0; itr--) {
ans[itr] += tot / c[itr];
tot -= (tot / c[itr]) * c[itr];
}
}
for (int i = 0; i < 5; i++) cout << ans[i] << " ";
cout << "\n";
cout << tot << "\n";
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
Naman has two binary strings s and t of length n (a binary string is a string which only consists of the characters "0" and "1"). He wants to convert s into t using the following operation as few times as possible.
In one operation, he can choose any subsequence of s and rotate it clockwise once.
For example, if s = 1110100, he can choose a subsequence corresponding to indices (1-based) \{2, 6, 7 \} and rotate them clockwise. The resulting string would then be s = 1010110.
A string a is said to be a subsequence of string b if a can be obtained from b by deleting some characters without changing the ordering of the remaining characters.
To perform a clockwise rotation on a sequence c of size k is to perform an operation which sets c_1:=c_k, c_2:=c_1, c_3:=c_2, β¦, c_k:=c_{k-1} simultaneously.
Determine the minimum number of operations Naman has to perform to convert s into t or say that it is impossible.
Input
The first line contains a single integer n (1 β€ n β€ 10^6) β the length of the strings.
The second line contains the binary string s of length n.
The third line contains the binary string t of length n.
Output
If it is impossible to convert s to t after any number of operations, print -1.
Otherwise, print the minimum number of operations required.
Examples
Input
6
010000
000001
Output
1
Input
10
1111100000
0000011111
Output
5
Input
8
10101010
01010101
Output
1
Input
10
1111100000
1111100001
Output
-1
Note
In the first test, Naman can choose the subsequence corresponding to indices \{2, 6\} and rotate it once to convert s into t.
In the second test, he can rotate the subsequence corresponding to all indices 5 times. It can be proved, that it is the minimum required number of operations.
In the last test, it is impossible to convert s into t.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int n;
cin >> n;
string s, t;
cin >> s >> t;
long long int cnt = 0;
long long int ans = 0;
long long int mn = 0, mx = 0;
for (long long int i = 0; i < (long long int)(n); i++) {
if (s[i] == '0' && t[i] == '1')
cnt++;
else if (s[i] == '1' && t[i] == '0')
cnt--;
ans = max({ans, abs(cnt - mx), abs(cnt - mn)});
mn = min(mn, cnt);
mx = max(mx, cnt);
}
if (cnt != 0) {
cout << -1 << '\n';
return;
}
cout << ans << '\n';
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t = 1;
for (long long int i = 0; i < (long long int)(t); i++) {
solve();
}
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
You are given a tree (an undirected connected graph without cycles) and an integer s.
Vanya wants to put weights on all edges of the tree so that all weights are non-negative real numbers and their sum is s. At the same time, he wants to make the diameter of the tree as small as possible.
Let's define the diameter of a weighed tree as the maximum sum of the weights of the edges lying on the path between two some vertices of the tree. In other words, the diameter of a weighed tree is the length of the longest simple path in the tree, where length of a path is equal to the sum of weights over all edges in the path.
Find the minimum possible diameter that Vanya can get.
Input
The first line contains two integer numbers n and s (2 β€ n β€ 10^5, 1 β€ s β€ 10^9) β the number of vertices in the tree and the sum of edge weights.
Each of the following nβ1 lines contains two space-separated integer numbers a_i and b_i (1 β€ a_i, b_i β€ n, a_i β b_i) β the indexes of vertices connected by an edge. The edges are undirected.
It is guaranteed that the given edges form a tree.
Output
Print the minimum diameter of the tree that Vanya can get by placing some non-negative real weights on its edges with the sum equal to s.
Your answer will be considered correct if its absolute or relative error does not exceed 10^{-6}.
Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if \frac {|a-b|} {max(1, b)} β€ 10^{-6}.
Examples
Input
4 3
1 2
1 3
1 4
Output
2.000000000000000000
Input
6 1
2 1
2 3
2 5
5 4
5 6
Output
0.500000000000000000
Input
5 5
1 2
2 3
3 4
3 5
Output
3.333333333333333333
Note
In the first example it is necessary to put weights like this:
<image>
It is easy to see that the diameter of this tree is 2. It can be proved that it is the minimum possible diameter.
In the second example it is necessary to put weights like this:
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<int> v[100010];
int main() {
int k = 0, n, s, x, y, i;
long double ans;
cin >> n >> s;
for (i = 0; i < n - 1; i++) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
for (i = 1; i <= n; i++) {
if (v[i].size() == 1) k++;
}
ans = 1.0 * s / k * 2;
cout << setprecision(21) << ans << endl;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
While creating high loaded systems one should pay a special attention to caching. This problem will be about one of the most popular caching algorithms called LRU (Least Recently Used).
Suppose the cache may store no more than k objects. At the beginning of the workflow the cache is empty. When some object is queried we check if it is present in the cache and move it here if it's not. If there are more than k objects in the cache after this, the least recently used one should be removed. In other words, we remove the object that has the smallest time of the last query.
Consider there are n videos being stored on the server, all of the same size. Cache can store no more than k videos and caching algorithm described above is applied. We know that any time a user enters the server he pick the video i with probability pi. The choice of the video is independent to any events before.
The goal of this problem is to count for each of the videos the probability it will be present in the cache after 10100 queries.
Input
The first line of the input contains two integers n and k (1 β€ k β€ n β€ 20) β the number of videos and the size of the cache respectively. Next line contains n real numbers pi (0 β€ pi β€ 1), each of them is given with no more than two digits after decimal point.
It's guaranteed that the sum of all pi is equal to 1.
Output
Print n real numbers, the i-th of them should be equal to the probability that the i-th video will be present in the cache after 10100 queries. You answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct, if <image>.
Examples
Input
3 1
0.3 0.2 0.5
Output
0.3 0.2 0.5
Input
2 1
0.0 1.0
Output
0.0 1.0
Input
3 2
0.3 0.2 0.5
Output
0.675 0.4857142857142857 0.8392857142857143
Input
3 3
0.2 0.3 0.5
Output
1.0 1.0 1.0
### Response
```cpp
#include <bits/stdc++.h>
double p[22], d[(1 << 20) + 10];
double ans[22];
int hmany(int a) {
int ret = 0;
while (a) {
if (a % 2) ret++;
a >>= 1;
}
return ret;
}
int n, k;
int main() {
scanf("%d%d", &n, &k);
int num = 0;
for (int i = 1; i <= n; i++) {
scanf("%lf", &p[i]);
if (p[i] == 0) num++;
}
if (n - num < k) k = n - num;
memset(d, 0, sizeof(d));
d[0] = 1.0;
for (int i = 0; i < (1 << n); i++) {
int tmp = i;
double tmpp = 0.0;
int tmpk = 0;
for (int j = 1; j <= n; j++) {
if (i & (1 << (j - 1))) {
tmpk++;
} else
tmpp += p[j];
}
if (tmpk >= k) continue;
for (int j = 1; j <= n; j++) {
if (((1 << (j - 1)) & i) == 0) {
d[i | (1 << (j - 1))] += d[i] * (p[j] / tmpp);
}
}
}
memset(ans, 0, sizeof(ans));
for (int i = 0; i < (1 << n); i++) {
if (hmany(i) != k) continue;
for (int j = 1; j <= n; j++) {
if ((1 << (j - 1)) & i) {
ans[j] += d[i];
}
}
}
for (int i = 1; i <= n; i++) {
printf("%.10lf\n", ans[i]);
}
return 0;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
Many people are aware of DMCA β Digital Millennium Copyright Act. But another recently proposed DMCA β Digital Millennium Calculation Act β is much less known.
In this problem you need to find a root of a number according to this new DMCA law.
Input
The input contains a single integer a (1 β€ a β€ 1000000).
Output
Output the result β an integer number.
Examples
Input
1
Output
1
Input
81
Output
9
### Response
```cpp
/******************************************************************************
Online C++ Compiler.
Code, Compile, Run and Debug C++ program online.
Write your code in this editor and press "Run" button to compile and execute it.
*******************************************************************************/
#include <bits/stdc++.h>
#define ll long long int
#define ld long double
using namespace std;
void Void(){
int64_t n;
cin >> n;
while(n >= 10){
int64_t sum = 0;
int64_t a = n;
while(a != 0){
sum += a % 10;
a /= 10;
}
n = sum;
}
cout << n << endl;
}
int main(){
int t = 1;
// cin >> t;
while(t--)Void();
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
Little Chris is a huge fan of linear algebra. This time he has been given a homework about the unusual square of a square matrix.
The dot product of two integer number vectors x and y of size n is the sum of the products of the corresponding components of the vectors. The unusual square of an n Γ n square matrix A is defined as the sum of n dot products. The i-th of them is the dot product of the i-th row vector and the i-th column vector in the matrix A.
Fortunately for Chris, he has to work only in GF(2)! This means that all operations (addition, multiplication) are calculated modulo 2. In fact, the matrix A is binary: each element of A is either 0 or 1. For example, consider the following matrix A:
<image>
The unusual square of A is equal to (1Β·1 + 1Β·0 + 1Β·1) + (0Β·1 + 1Β·1 + 1Β·0) + (1Β·1 + 0Β·1 + 0Β·0) = 0 + 1 + 1 = 0.
However, there is much more to the homework. Chris has to process q queries; each query can be one of the following:
1. given a row index i, flip all the values in the i-th row in A;
2. given a column index i, flip all the values in the i-th column in A;
3. find the unusual square of A.
To flip a bit value w means to change it to 1 - w, i.e., 1 changes to 0 and 0 changes to 1.
Given the initial matrix A, output the answers for each query of the third type! Can you solve Chris's homework?
Input
The first line of input contains an integer n (1 β€ n β€ 1000), the number of rows and the number of columns in the matrix A. The next n lines describe the matrix: the i-th line contains n space-separated bits and describes the i-th row of A. The j-th number of the i-th line aij (0 β€ aij β€ 1) is the element on the intersection of the i-th row and the j-th column of A.
The next line of input contains an integer q (1 β€ q β€ 106), the number of queries. Each of the next q lines describes a single query, which can be one of the following:
* 1 i β flip the values of the i-th row;
* 2 i β flip the values of the i-th column;
* 3 β output the unusual square of A.
Note: since the size of the input and output could be very large, don't use slow output techniques in your language. For example, do not use input and output streams (cin, cout) in C++.
Output
Let the number of the 3rd type queries in the input be m. Output a single string s of length m, where the i-th symbol of s is the value of the unusual square of A for the i-th query of the 3rd type as it appears in the input.
Examples
Input
3
1 1 1
0 1 1
1 0 0
12
3
2 3
3
2 2
2 2
1 3
3
3
1 2
2 1
1 1
3
Output
01001
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline int size(const T& c) {
return c.size();
}
using namespace std;
int fastMax(int x, int y) { return (((y - x) >> (32 - 1)) & (x ^ y)) ^ y; }
int fastMin(int x, int y) { return (((y - x) >> (32 - 1)) & (x ^ y)) ^ x; }
const int maxn = 1000 + 10;
int n, u, q, com;
int res;
int main() {
cin >> n;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
scanf("%d", &u);
if (i == j) res = (res + u) % 2;
}
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
scanf("%d", &com);
if (com == 3)
printf("%d", res);
else {
scanf("%d", &u);
res = 1 - res;
}
}
fclose(stdin);
fclose(stdout);
return 0;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
A sequence of n integers is written on a blackboard. Soon Sasha will come to the blackboard and start the following actions: let x and y be two adjacent numbers (x before y), then he can remove them and write x + 2y instead of them. He will perform these operations until one number is left. Sasha likes big numbers and will get the biggest possible number.
Nikita wants to get to the blackboard before Sasha and erase some of the numbers. He has q options, in the option i he erases all numbers to the left of the li-th number and all numbers to the right of ri-th number, i. e. all numbers between the li-th and the ri-th, inclusive, remain on the blackboard. For each of the options he wants to know how big Sasha's final number is going to be. This number can be very big, so output it modulo 109 + 7.
Input
The first line contains two integers n and q (1 β€ n, q β€ 105) β the number of integers on the blackboard and the number of Nikita's options.
The next line contains n integers a1, a2, ..., an ( - 109 β€ ai β€ 109) β the sequence on the blackboard.
Each of the next q lines contains two integers li and ri (1 β€ li β€ ri β€ n), describing Nikita's options.
Output
For each option output Sasha's result modulo 109 + 7.
Examples
Input
3 3
1 2 3
1 3
1 2
2 3
Output
17
5
8
Input
3 1
1 2 -3
1 3
Output
1000000006
Input
4 2
1 1 1 -1
1 4
3 4
Output
5
1000000006
Note
In the second sample Nikita doesn't erase anything. Sasha first erases the numbers 1 and 2 and writes 5. Then he erases 5 and -3 and gets -1. -1 modulo 109 + 7 is 109 + 6.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool chkmin(T &x, T y) {
return y < x ? x = y, 1 : 0;
}
template <typename T>
inline bool chkmax(T &x, T y) {
return x < y ? x = y, 1 : 0;
}
const int INF = 0x3f3f3f3f;
const int N = 1e5 + 10, Max = 2e9, mod = 1e9 + 7;
vector<pair<int, int> > Q[N];
int a[N], pre[N], fa[N], Pw[N], Suf[N], Sum[N], ans[N];
inline int read() {
int x = 0, flag = 1;
char ch = getchar();
while (!isdigit(ch) && ch != '-') ch = getchar();
if (ch == '-') flag = -1, ch = getchar();
while (isdigit(ch)) x = (x << 3) + (x << 1) + (ch - '0'), ch = getchar();
return x * flag;
}
inline int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
inline void Merge(int x, int y) {
fa[x] = fa[y], pre[y] = pre[x];
long long Len = x - pre[x];
if ((Len > 30 && a[y] > 0) || (a[x] + (1ll * a[y] << Len) > Max))
a[y] = Max + 10;
else
a[y] = a[x] + (a[y] << Len);
}
inline int Query(int l, int r) {
return (Suf[l] - 1ll * Suf[r + 1] * Pw[r - l + 1] % mod + mod) % mod;
}
int main() {
int n = read(), q = read();
Pw[0] = 1;
for (int i = (1), iend = (n); i <= iend; i++)
a[i] = read(), pre[i] = i - 1, fa[i] = i, Pw[i] = Pw[i - 1] * 2 % mod;
for (int i = (n), iend = (1); i >= iend; i--)
Suf[i] = (Suf[i + 1] * 2ll + a[i] + mod) % mod;
for (int i = (1), iend = (q); i <= iend; i++) {
int l = read(), r = read();
Q[r].push_back(make_pair(l, i));
}
for (int i = (1), iend = (n); i <= iend; i++) {
while (pre[i] && a[i] > 0) Merge(pre[i], i);
Sum[i] = (Sum[pre[i]] + 2ll * Query(pre[i] + 1, i)) % mod;
for (int j = (0), jend = (Q[i].size() - 1); j <= jend; j++) {
int pos = find(Q[i][j].first);
ans[Q[i][j].second] =
((Sum[i] - Sum[pos] + Query(Q[i][j].first, pos)) % mod + mod) % mod;
}
}
for (int i = (1), iend = (q); i <= iend; i++) printf("%d\n", ans[i]);
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
Vova's family is building the Great Vova Wall (named by Vova himself). Vova's parents, grandparents, grand-grandparents contributed to it. Now it's totally up to Vova to put the finishing touches.
The current state of the wall can be respresented by a sequence a of n integers, with a_i being the height of the i-th part of the wall.
Vova can only use 2 Γ 1 bricks to put in the wall (he has infinite supply of them, however).
Vova can put bricks horizontally on the neighboring parts of the wall of equal height. It means that if for some i the current height of part i is the same as for part i + 1, then Vova can put a brick there and thus increase both heights by 1. Obviously, Vova can't put bricks in such a way that its parts turn out to be off the borders (to the left of part 1 of the wall or to the right of part n of it).
The next paragraph is specific to the version 1 of the problem.
Vova can also put bricks vertically. That means increasing height of any part of the wall by 2.
Vova is a perfectionist, so he considers the wall completed when:
* all parts of the wall has the same height;
* the wall has no empty spaces inside it.
Can Vova complete the wall using any amount of bricks (possibly zero)?
Input
The first line contains a single integer n (1 β€ n β€ 2 β
10^5) β the number of parts in the wall.
The second line contains n integers a_1, a_2, ..., a_n (1 β€ a_i β€ 10^9) β the initial heights of the parts of the wall.
Output
Print "YES" if Vova can complete the wall using any amount of bricks (possibly zero).
Print "NO" otherwise.
Examples
Input
5
2 1 1 2 5
Output
YES
Input
3
4 5 3
Output
YES
Input
2
10 10
Output
YES
Input
3
1 2 3
Output
NO
Note
In the first example Vova can put a brick on parts 2 and 3 to make the wall [2, 2, 2, 2, 5] and then put 3 bricks on parts 1 and 2 and 3 bricks on parts 3 and 4 to make it [5, 5, 5, 5, 5].
In the second example Vova can put a brick vertically on part 3 to make the wall [4, 5, 5], then horizontally on parts 2 and 3 to make it [4, 6, 6] and then vertically on part 1 to make it [6, 6, 6].
In the third example the wall is already complete.
### Response
```cpp
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
using namespace std;
const int MAX = 2e5 + 5;
const long long MAX2 = 11;
const int MOD = 1000000000 + 7;
const long long INF = 20000;
const int dr[] = {1, 0, -1, 0, 1, 1, -1, -1};
const int dc[] = {0, 1, 0, -1, 1, -1, 1, -1};
const double pi = acos(-1);
const double EPS = 1e-9;
int n, x[MAX], mx;
stack<int> s;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
if (n == 1) return cout << "YES", 0;
x[0] = x[n + 1] = 2e9;
for (int i = 1; i <= n; i++) {
cin >> x[i];
mx = max(mx, x[i]);
if (s.empty() || s.top() != x[i])
s.push(x[i]);
else
s.pop();
}
for (int i = 1; i <= n; i++)
if (x[i - 1] > x[i] && x[i + 1] > x[i]) return cout << "NO", 0;
if (s.empty() || (s.size() < 2 && s.top() == mx))
cout << "YES";
else
cout << "NO";
return 0;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
Sometimes one has to spell email addresses over the phone. Then one usually pronounces a dot as dot, an at sign as at. As a result, we get something like vasyaatgmaildotcom. Your task is to transform it into a proper email address ([email protected]).
It is known that a proper email address contains only such symbols as . @ and lower-case Latin letters, doesn't start with and doesn't end with a dot. Also, a proper email address doesn't start with and doesn't end with an at sign. Moreover, an email address contains exactly one such symbol as @, yet may contain any number (possible, zero) of dots.
You have to carry out a series of replacements so that the length of the result was as short as possible and it was a proper email address. If the lengths are equal, you should print the lexicographically minimal result.
Overall, two variants of replacement are possible: dot can be replaced by a dot, at can be replaced by an at.
Input
The first line contains the email address description. It is guaranteed that that is a proper email address with all the dots replaced by dot an the at signs replaced by at. The line is not empty and its length does not exceed 100 symbols.
Output
Print the shortest email address, from which the given line could be made by the described above replacements. If there are several solutions to that problem, print the lexicographically minimal one (the lexicographical comparison of the lines are implemented with an operator < in modern programming languages).
In the ASCII table the symbols go in this order: . @ ab...z
Examples
Input
vasyaatgmaildotcom
Output
[email protected]
Input
dotdotdotatdotdotat
Output
[email protected]
Input
aatt
Output
a@t
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
char s[110];
int main() {
scanf("%s", s);
int n = strlen(s);
bool et = false;
for (int i = 0; i < n; i++) {
bool printed = false;
if (i != 0 && i + 2 != n - 1) {
if (s[i] == 'd' && s[i + 1] == 'o' && s[i + 2] == 't') {
printf(".");
i += 2;
printed = true;
}
}
if (i != 0 && i + 1 != n - 1 && !et) {
if (s[i] == 'a' && s[i + 1] == 't') {
printf("@");
i += 1;
printed = true;
et = true;
}
}
if (!printed) printf("%c", s[i]);
}
printf("\n");
return 0;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
The official capital and the cultural capital of Berland are connected by a single road running through n regions. Each region has a unique climate, so the i-th (1 β€ i β€ n) region has a stable temperature of ti degrees in summer.
This summer a group of m schoolchildren wants to get from the official capital to the cultural capital to visit museums and sights. The trip organizers transport the children between the cities in buses, but sometimes it is very hot. Specifically, if the bus is driving through the i-th region and has k schoolchildren, then the temperature inside the bus is ti + k degrees.
Of course, nobody likes it when the bus is hot. So, when the bus drives through the i-th region, if it has more than Ti degrees inside, each of the schoolchild in the bus demands compensation for the uncomfortable conditions. The compensation is as large as xi rubles and it is charged in each region where the temperature in the bus exceeds the limit.
To save money, the organizers of the trip may arbitrarily add or remove extra buses in the beginning of the trip, and between regions (of course, they need at least one bus to pass any region). The organizers can also arbitrarily sort the children into buses, however, each of buses in the i-th region will cost the organizers costi rubles. Please note that sorting children into buses takes no money.
Your task is to find the minimum number of rubles, which the organizers will have to spend to transport all schoolchildren.
Input
The first input line contains two integers n and m (1 β€ n β€ 105; 1 β€ m β€ 106) β the number of regions on the way and the number of schoolchildren in the group, correspondingly. Next n lines contain four integers each: the i-th line contains ti, Ti, xi and costi (1 β€ ti, Ti, xi, costi β€ 106). The numbers in the lines are separated by single spaces.
Output
Print the only integer β the minimum number of roubles the organizers will have to spend to transport all schoolchildren.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use cin, cout streams or the %I64d specifier.
Examples
Input
2 10
30 35 1 100
20 35 10 10
Output
120
Input
3 100
10 30 1000 1
5 10 1000 3
10 40 1000 100000
Output
200065
Note
In the first sample the organizers will use only one bus to travel through the first region. However, the temperature in the bus will equal 30 + 10 = 40 degrees and each of 10 schoolchildren will ask for compensation. Only one bus will transport the group through the second region too, but the temperature inside won't exceed the limit. Overall, the organizers will spend 100 + 10 + 10 = 120 rubles.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long ans = 0;
for (int i = (0); i < (n); ++i) {
long long t, T, x, cost;
cin >> t >> T >> x >> cost;
if (t >= T) {
ans += cost + m * x;
continue;
}
long long aux1 = cost;
if (m > (T - t)) aux1 += m * x;
long long aux2 = (long long)ceil((double)(m - (T - t)) / (T - t)) + 1;
aux2 *= cost;
ans += min(aux1, aux2);
}
cout << ans << endl;
return 0;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
Alice and Bob are playing a fun game of tree tag.
The game is played on a tree of n vertices numbered from 1 to n. Recall that a tree on n vertices is an undirected, connected graph with n-1 edges.
Initially, Alice is located at vertex a, and Bob at vertex b. They take turns alternately, and Alice makes the first move. In a move, Alice can jump to a vertex with distance at most da from the current vertex. And in a move, Bob can jump to a vertex with distance at most db from the current vertex. The distance between two vertices is defined as the number of edges on the unique simple path between them. In particular, either player is allowed to stay at the same vertex in a move. Note that when performing a move, a player only occupies the starting and ending vertices of their move, not the vertices between them.
If after at most 10^{100} moves, Alice and Bob occupy the same vertex, then Alice is declared the winner. Otherwise, Bob wins.
Determine the winner if both players play optimally.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 10^4). Description of the test cases follows.
The first line of each test case contains five integers n,a,b,da,db (2β€ nβ€ 10^5, 1β€ a,bβ€ n, aβ b, 1β€ da,dbβ€ n-1) β the number of vertices, Alice's vertex, Bob's vertex, Alice's maximum jumping distance, and Bob's maximum jumping distance, respectively.
The following n-1 lines describe the edges of the tree. The i-th of these lines contains two integers u, v (1β€ u, vβ€ n, uβ v), denoting an edge between vertices u and v. It is guaranteed that these edges form a tree structure.
It is guaranteed that the sum of n across all test cases does not exceed 10^5.
Output
For each test case, output a single line containing the winner of the game: "Alice" or "Bob".
Example
Input
4
4 3 2 1 2
1 2
1 3
1 4
6 6 1 2 5
1 2
6 5
2 3
3 4
4 5
9 3 9 2 5
1 2
1 6
1 9
1 3
9 5
7 9
4 8
4 3
11 8 11 3 3
1 2
11 9
4 9
6 5
2 10
3 2
5 9
8 3
7 4
7 10
Output
Alice
Bob
Alice
Alice
Note
In the first test case, Alice can win by moving to vertex 1. Then wherever Bob moves next, Alice will be able to move to the same vertex on the next move.
<image>
In the second test case, Bob has the following strategy to win. Wherever Alice moves, Bob will always move to whichever of the two vertices 1 or 6 is farthest from Alice.
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
const int inf = 0x3f3f3f3f;
const int mod = 1e9 + 7;
int n, m, k, t, mx, mi, x, y, u, v, dx, dy, idx, cnt, tot, sum, res, flag, st;
vector<int> e[maxn];
void dfs(int u, int pre, int dep, int op) {
if (dep > mx) {
mx = dep;
idx = u;
}
if (u == y && op && dep <= dx) {
flag = 1;
return;
}
for (int v : e[u]) {
if (v == pre) continue;
dfs(v, u, dep + 1, op);
}
}
int main() {
scanf("%d", &t);
while (t--) {
flag = 0;
scanf("%d %d %d %d %d", &n, &x, &y, &dx, &dy);
for (int i = 1; i <= n; i++) {
e[i].clear();
}
for (int i = 1; i < n; i++) {
scanf("%d %d", &u, &v);
e[u].push_back(v);
e[v].push_back(u);
}
mx = 0;
dfs(x, 0, 0, 1);
if (flag) {
puts("Alice");
continue;
}
mx = 0;
dfs(idx, 0, 0, 0);
puts(2 * dx >= mx || dy <= 2 * dx ? "Alice" : "Bob");
}
return 0;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
Fedor runs for president of Byteland! In the debates, he will be asked how to solve Byteland's transport problem. It's a really hard problem because of Byteland's transport system is now a tree (connected graph without cycles). Fedor's team has found out in the ministry of transport of Byteland that there is money in the budget only for one additional road. In the debates, he is going to say that he will build this road as a way to maximize the number of distinct simple paths in the country. A simple path is a path which goes through every vertex no more than once. Two simple paths are named distinct if sets of their edges are distinct.
But Byteland's science is deteriorated, so Fedor's team hasn't succeeded to find any scientists to answer how many distinct simple paths they can achieve after adding exactly one edge on the transport system?
Help Fedor to solve it.
An edge can be added between vertices that are already connected, but it can't be a loop.
In this problem, we consider only simple paths of length at least two.
Input
The first line contains one integer n (2 β€ n β€ 500\ 000) β number of vertices in Byteland's transport system.
Each of the following n - 1 lines contains two integers v_i and u_i (1 β€ v_i, u_i β€ n). It's guaranteed that the graph is tree.
Output
Print exactly one integer β a maximal number of simple paths that can be achieved after adding one edge.
Examples
Input
2
1 2
Output
2
Input
4
1 2
1 3
1 4
Output
11
Input
6
1 2
1 3
3 4
3 5
4 6
Output
29
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 500001;
struct Edge {
int y, next;
} adj[MAXN * 2];
struct State {
int size;
long long f;
} state[MAXN];
int fch[MAXN], size[MAXN];
long long f[MAXN], ans;
int que[MAXN];
int n, m;
void add(int u, int v) {
adj[++m] = (Edge){v, fch[u]};
fch[u] = m;
}
long long square(int x) { return x * 1LL * x; }
long long check(State a, State b) {
return a.f + b.f + square(n - a.size - b.size);
}
bool cross(State a, State b, State c) {
double y0 = a.f + square(a.size);
double x1 = b.size - a.size, y1 = b.f + square(b.size) - y0;
double x2 = c.size - a.size, y2 = c.f + square(c.size) - y0;
return x1 * y2 < x2 * y1;
}
bool cmp(State a, State b) { return a.size > b.size; }
void dfs(int t, int parent) {
f[t] = 1LL << 60;
size[t] = 1;
for (int i = fch[t]; i != 0; i = adj[i].next) {
int v = adj[i].y;
if (v != parent) {
dfs(v, t);
size[t] += size[v];
}
}
if (size[t] == 1) {
f[t] = 1;
return;
}
int m = 0;
for (int i = fch[t]; i != 0; i = adj[i].next) {
int v = adj[i].y;
if (v != parent) {
long long c = f[v] + square(size[t] - size[v]);
if (c < f[t]) f[t] = c;
if (parent == 0) {
c = f[v] + square(n - size[v]);
if (c < ans) ans = c;
}
state[m++] = (State){size[v], f[v]};
}
}
if (m == 1) return;
sort(state, state + m, cmp);
int head = 0, tail = 0;
que[0] = 0;
for (int i = 1; i < m; i++) {
while (head < tail && check(state[i], state[que[head]]) >=
check(state[i], state[que[head + 1]]))
head++;
long long c = check(state[i], state[que[head]]);
if (c < ans) ans = c;
que[++tail] = i;
while (head + 1 < tail &&
cross(state[que[tail - 2]], state[que[tail - 1]], state[que[tail]]))
que[--tail] = i;
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
add(u, v);
add(v, u);
}
ans = square(n);
dfs(1, 0);
cout << (square(n) - ans) / 2 + (n * 1LL * (n - 1) / 2) << endl;
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
You are given n integers a1, a2, ..., an.
A sequence of integers x1, x2, ..., xk is called a "xor-sequence" if for every 1 β€ i β€ k - 1 the number of ones in the binary representation of the number xi <image> xi + 1's is a multiple of 3 and <image> for all 1 β€ i β€ k. The symbol <image> is used for the binary exclusive or operation.
How many "xor-sequences" of length k exist? Output the answer modulo 109 + 7.
Note if a = [1, 1] and k = 1 then the answer is 2, because you should consider the ones from a as different.
Input
The first line contains two integers n and k (1 β€ n β€ 100, 1 β€ k β€ 1018) β the number of given integers and the length of the "xor-sequences".
The second line contains n integers ai (0 β€ ai β€ 1018).
Output
Print the only integer c β the number of "xor-sequences" of length k modulo 109 + 7.
Examples
Input
5 2
15 1 2 4 8
Output
13
Input
5 1
15 1 2 4 8
Output
5
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
int d;
vector<vector<long long>> multiply(vector<vector<long long>> A,
vector<vector<long long>> B) {
vector<vector<long long>> C(d, vector<long long>(d));
for (int i = 0; i < d; i++)
for (int j = 0; j < d; j++)
for (int z = 0; z < d; z++)
C[i][j] = (C[i][j] + (A[i][z] * B[z][j]) % MOD) % MOD;
return C;
}
vector<vector<long long>> power(vector<vector<long long>> &A, long long p) {
if (p == 1) return A;
if (p & 1)
return multiply(A, power(A, p - 1));
else {
vector<vector<long long>> X = power(A, p / 2);
return multiply(X, X);
}
}
int main() {
ios::sync_with_stdio(0);
long long i, j, n;
long long k;
cin >> n >> k;
long long a[n];
for (i = 0; i < n; ++i) cin >> a[i];
d = n;
vector<vector<long long>> b(n, vector<long long>(n)),
c(n, vector<long long>(n));
for (i = 0; i < n; ++i) {
for (j = 0; j < n; ++j) {
b[i][j] = (__builtin_popcountll(a[i] ^ a[j]) % 3LL == 0);
}
}
if (k == 1) {
cout << n << "\n";
return 0;
}
c = power(b, k - 1);
long long ans = 0;
for (i = 0; i < n; ++i)
for (j = 0; j < n; ++j) ans = (ans + c[i][j]) % MOD;
cout << ans << "\n";
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
IT City company developing computer games invented a new way to reward its employees. After a new game release users start buying it actively, and the company tracks the number of sales with precision to each transaction. Every time when the next number of sales is divisible by all numbers from 2 to 10 every developer of this game gets a small bonus.
A game designer Petya knows that the company is just about to release a new game that was partly developed by him. On the basis of his experience he predicts that n people will buy the game during the first month. Now Petya wants to determine how many times he will get the bonus. Help him to know it.
Input
The only line of the input contains one integer n (1 β€ n β€ 1018) β the prediction on the number of people who will buy the game.
Output
Output one integer showing how many numbers from 1 to n are divisible by all numbers from 2 to 10.
Examples
Input
3000
Output
1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long temp = 0, r, l, w, k = 0, m1, e, p, q, ans = 0, k1 = 0, k2 = 0, d = 0,
a = 0, b = 0, s = 0, x, y, min1 = 1000000010, max1 = 0, m, c = 0,
t = 0, i, n, c1 = 0, tot = 0, t1, k4 = 0, c2 = 0, j = 0, k3 = 0;
char ch, ch1, ch2;
string s1, s2, s3;
signed main() {
cin >> n;
k = n - n / 2 - n / 3 - n / 5 - n / 7 + n / (2 * 3) + n / (3 * 5) +
n / (2 * 7) + n / (2 * 5) + n / (3 * 7) + n / (5 * 7) - n / (2 * 3 * 5) -
n / (2 * 5 * 7) - n / (3 * 5 * 7) - n / (2 * 3 * 7) + n / (2 * 3 * 5 * 7);
cout << k;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Vasya studies divisibility rules at school. Here are some of them:
* Divisibility by 2. A number is divisible by 2 if and only if its last digit is divisible by 2 or in other words, is even.
* Divisibility by 3. A number is divisible by 3 if and only if the sum of its digits is divisible by 3.
* Divisibility by 4. A number is divisible by 4 if and only if its last two digits form a number that is divisible by 4.
* Divisibility by 5. A number is divisible by 5 if and only if its last digit equals 5 or 0.
* Divisibility by 6. A number is divisible by 6 if and only if it is divisible by 2 and 3 simultaneously (that is, if the last digit is even and the sum of all digits is divisible by 3).
* Divisibility by 7. Vasya doesn't know such divisibility rule.
* Divisibility by 8. A number is divisible by 8 if and only if its last three digits form a number that is divisible by 8.
* Divisibility by 9. A number is divisible by 9 if and only if the sum of its digits is divisible by 9.
* Divisibility by 10. A number is divisible by 10 if and only if its last digit is a zero.
* Divisibility by 11. A number is divisible by 11 if and only if the sum of digits on its odd positions either equals to the sum of digits on the even positions, or they differ in a number that is divisible by 11.
Vasya got interested by the fact that some divisibility rules resemble each other. In fact, to check a number's divisibility by 2, 4, 5, 8 and 10 it is enough to check fulfiling some condition for one or several last digits. Vasya calls such rules the 2-type rules.
If checking divisibility means finding a sum of digits and checking whether the sum is divisible by the given number, then Vasya calls this rule the 3-type rule (because it works for numbers 3 and 9).
If we need to find the difference between the sum of digits on odd and even positions and check whether the difference is divisible by the given divisor, this rule is called the 11-type rule (it works for number 11).
In some cases we should divide the divisor into several factors and check whether rules of different types (2-type, 3-type or 11-type) work there. For example, for number 6 we check 2-type and 3-type rules, for number 66 we check all three types. Such mixed divisibility rules are called 6-type rules.
And finally, there are some numbers for which no rule works: neither 2-type, nor 3-type, nor 11-type, nor 6-type. The least such number is number 7, so we'll say that in such cases the mysterious 7-type rule works, the one that Vasya hasn't discovered yet.
Vasya's dream is finding divisibility rules for all possible numbers. He isn't going to stop on the decimal numbers only. As there are quite many numbers, ha can't do it all by himself. Vasya asked you to write a program that determines the divisibility rule type in the b-based notation for the given divisor d.
Input
The first input line contains two integers b and d (2 β€ b, d β€ 100) β the notation system base and the divisor. Both numbers are given in the decimal notation.
Output
On the first output line print the type of the rule in the b-based notation system, where the divisor is d: "2-type", "3-type", "11-type", "6-type" or "7-type". If there are several such types, print the one that goes earlier in the given sequence. If a number belongs to the 2-type, print on the second line the least number of the last b-based digits that we will need to use to check the divisibility.
Examples
Input
10 10
Output
2-type
1
Input
2 3
Output
11-type
Note
The divisibility rule for number 3 in binary notation looks as follows: "A number is divisible by 3 if and only if the sum of its digits that occupy the even places differs from the sum of digits that occupy the odd places, in a number that is divisible by 3". That's an 11-type rule. For example, 2110 = 101012. For it the sum of digits on odd positions equals 1 + 1 + 1 = 3, an on even positions β 0 + 0 = 0. The rule works and the number is divisible by 3.
In some notations a number can fit into the 3-type rule and the 11-type rule. In this case the correct answer is "3-type".
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m, s;
int gcd(int a, int b) {
int t;
while (b != 0) {
t = a % b;
a = b;
b = t;
}
return a;
}
int main() {
scanf("%d%d", &n, &m);
while (gcd(n, m) > 1) m /= gcd(n, m), s++;
if (m == 1)
printf("2-type\n%d\n", s);
else {
if ((n - 1) * (n + 1) / gcd(n - 1, n + 1) % m == 0) {
if (!s && (n - 1) % m == 0)
puts("3-type");
else if (!s && (n + 1) % m == 0)
puts("11-type");
else
puts("6-type");
} else
puts("7-type");
}
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
Little Petya is now fond of data compression algorithms. He has already studied gz, bz, zip algorithms and many others. Inspired by the new knowledge, Petya is now developing the new compression algorithm which he wants to name dis.
Petya decided to compress tables. He is given a table a consisting of n rows and m columns that is filled with positive integers. He wants to build the table a' consisting of positive integers such that the relative order of the elements in each row and each column remains the same. That is, if in some row i of the initial table ai, j < ai, k, then in the resulting table a'i, j < a'i, k, and if ai, j = ai, k then a'i, j = a'i, k. Similarly, if in some column j of the initial table ai, j < ap, j then in compressed table a'i, j < a'p, j and if ai, j = ap, j then a'i, j = a'p, j.
Because large values require more space to store them, the maximum value in a' should be as small as possible.
Petya is good in theory, however, he needs your help to implement the algorithm.
Input
The first line of the input contains two integers n and m (<image>, the number of rows and the number of columns of the table respectively.
Each of the following n rows contain m integers ai, j (1 β€ ai, j β€ 109) that are the values in the table.
Output
Output the compressed table in form of n lines each containing m integers.
If there exist several answers such that the maximum number in the compressed table is minimum possible, you are allowed to output any of them.
Examples
Input
2 2
1 2
3 4
Output
1 2
2 3
Input
4 3
20 10 30
50 40 30
50 60 70
90 80 70
Output
2 1 3
5 4 3
5 6 7
9 8 7
Note
In the first sample test, despite the fact a1, 2 β a21, they are not located in the same row or column so they may become equal after the compression.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m, nvt;
int **a, **id;
int dsu[1000010];
set<int> adj[1000010];
int din[1000010];
int DSU(int u) { return u == dsu[u] ? u : dsu[u] = DSU(dsu[u]); }
int merge(int u, int v) {
int U = DSU(u);
int V = DSU(v);
dsu[U] = V;
return V;
}
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
q;
bool gone[1000010];
int value[1000010];
int main() {
scanf("%d%d", &n, &m);
a = new int *[n];
id = new int *[n];
nvt = 0;
for (int i = 0; i < n; ++i) {
a[i] = new int[m];
id[i] = new int[m];
for (int j = 0; j < m; ++j) {
scanf("%d", &a[i][j]);
id[i][j] = ++nvt;
dsu[nvt] = nvt;
}
}
for (int i = 0; i < n; ++i) {
map<int, int> assign;
for (int j = 0; j < m; ++j) {
if (assign.count(a[i][j]))
assign[a[i][j]] = merge(id[i][j], assign[a[i][j]]);
else
assign[a[i][j]] = id[i][j];
}
}
for (int j = 0; j < m; ++j) {
map<int, int> assign;
for (int i = 0; i < n; ++i) {
if (assign.count(a[i][j]))
assign[a[i][j]] = merge(id[i][j], assign[a[i][j]]);
else
assign[a[i][j]] = id[i][j];
}
}
for (int i = 0; i < n; ++i) {
map<int, int> assign;
for (int j = 0; j < m; ++j) assign[a[i][j]] = DSU(id[i][j]);
for (int j = 0; j < m; ++j) {
map<int, int>::iterator it = assign.upper_bound(a[i][j]);
if (it != assign.end()) adj[assign[a[i][j]]].insert(it->second);
}
}
for (int j = 0; j < m; ++j) {
map<int, int> assign;
for (int i = 0; i < n; ++i) assign[a[i][j]] = DSU(id[i][j]);
for (int i = 0; i < n; ++i) {
map<int, int>::iterator it = assign.upper_bound(a[i][j]);
if (it != assign.end()) adj[assign[a[i][j]]].insert(it->second);
}
}
for (int i = 1; i <= nvt; ++i) {
if (DSU(i) != i) continue;
for (set<int>::iterator it = adj[i].begin(); it != adj[i].end(); ++it)
din[*it]++;
}
for (int i = 1; i <= nvt; ++i) {
if (DSU(i) != i) continue;
q.push(make_pair(din[i], i));
value[i] = 1;
}
while (!q.empty()) {
pair<int, int> cur = q.top();
q.pop();
if (gone[cur.second]) continue;
gone[cur.second] = true;
for (set<int>::iterator it = adj[cur.second].begin();
it != adj[cur.second].end(); ++it) {
value[*it] = max(value[*it], value[cur.second] + 1);
din[*it]--;
q.push(make_pair(din[*it], *it));
}
}
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) a[i][j] = value[DSU(id[i][j])];
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) printf("%d ", a[i][j]);
printf("\n");
}
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
There are league games and tournament games in sports competitions. In soccer league games, points are given to each of the wins, losses, and draws, and the rankings are competed based on the points. The points are win (3 points), negative (0 points), and draw (1 point), respectively.
Enter the number of teams and the results of the league match, sort them in order of best results (in descending order of points), and create a program that outputs the team name and points. If the points are tied, output in the order of input.
Input
Given multiple datasets. Each dataset is given in the following format:
n
name1 w1 l1 d1
name2 w2 l2 d2
::
namen wn ln dn
The number of teams n (n β€ 10) is given on the first line. The next n lines are given the name of team i (alphabet of up to 20 characters), the number of wins wi, the number of negatives li, and the number of draws di (0 β€ wi, li, di β€ 9), separated by spaces. ..
When the number of teams is 0, the input is completed. The number of datasets does not exceed 50.
Output
Print a sorted list of teams for each dataset. Print the name of the i-th team and the points on the i-line, separated by commas.
Insert one blank line between the datasets.
Example
Input
4
Japan 1 0 2
Egypt 1 2 0
Canada 0 2 1
Spain 2 0 1
3
India 0 2 0
Poland 1 0 1
Italy 1 0 1
0
Output
Spain,7
Japan,5
Egypt,3
Canada,1
Poland,4
Italy,4
India,0
### Response
```cpp
// 2011/02/02 Tazoe
#include <iostream>
#include <string>
using namespace std;
struct score{
string nam;
int win;
int los;
int drw;
int ord;
int pnt;
};
int main()
{
bool flg = false;
while(true){
int n;
cin >> n;
if(n==0)
break;
if(flg)
cout << endl;
else
flg = true;
struct score tem[10];
for(int i=0; i<n; i++){
cin >> tem[i].nam >> tem[i].win >> tem[i].los >> tem[i].drw;
tem[i].ord = i;
}
for(int i=0; i<n; i++)
tem[i].pnt = tem[i].win*3+tem[i].drw;
for(int i=0; i<n-1; i++)
for(int j=i+1; j<n; j++)
if(tem[i].pnt<tem[j].pnt||(tem[i].pnt==tem[j].pnt&&tem[i].ord>tem[j].ord)){
struct score tmp = tem[i];
tem[i] = tem[j];
tem[j] = tmp;
}
for(int i=0; i<n; i++)
cout << tem[i].nam << ',' << tem[i].pnt << endl;
}
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
There is a grid of size W Γ H surrounded by walls. Some cells in the grid are occupied by slimes. The slimes want to unite with each other and become a "King Slime".
In each move, a slime can move to east, west, south and north direction until it enters a cell occupied by another slime or hit the surrounding wall. If two slimes come together, they unite and become a new slime.
Your task is write a program which calculates the minimum number of moves that all the slimes unite and become a King Slime. Suppose slimes move one by one and they never move simultaneously.
Input
The first line contains three integers N (2 β€ N β€ 40,000), W and H (1 β€ W, H β€ 100,000), which denote the number of slimes, the width and the height of the grid respectively.
The following N lines describe the initial coordinates of the slimes. The i-th line contains two integers xi (1 β€ xi β€ W) and yi (1 β€ yi β€ H), which indicate the coordinates of the i-th slime . All the coordinates are 1-based.
You may assume that each cell is occupied by at most one slime initially.
Output
Output the minimum number of moves that all the slimes unite and become a King Slime.
Examples
Input
4 3 3
1 1
1 3
3 1
3 3
Output
3
Input
2 3 3
2 2
3 3
Output
2
Input
2 4 4
2 2
3 3
Output
3
Input
2 4 4
2 2
2 3
Output
1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<int> Ws[100001], Hs[100001];
int par[40000];
int find(int x)
{
return (par[x] >= 0 ? par[x] = find(par[x]) : x);
}
void merge(int x, int y)
{
x = find(x);
y = find(y);
if (x == y) return;
if (-par[x] < -par[y]) swap(x, y);
par[x] += par[y];
par[y] = x;
}
int main()
{
int n, w, h;
int cw = 0, ch = 0;
scanf("%d %d %d", &n, &w, &h);
for (int i = 0; i < n; i++){
int a, b;
scanf("%d %d", &a, &b);
if (a == 1 || a == w) cw = 1;
if (b == 1 || b == h) ch = 1;
Ws[a].push_back(i);
Hs[b].push_back(i);
}
memset(par, -1, sizeof(par));
for (int i = 1; i <= w; i++){
for (int j = 1; j < Ws[i].size(); j++){
merge(Ws[i][j - 1], Ws[i][j]);
}
}
for (int i = 1; i <= h; i++){
for (int j = 1; j < Hs[i].size(); j++){
merge(Hs[i][j - 1], Hs[i][j]);
}
}
set<int> s;
for (int i = 0; i < n; i++) s.insert(find(i));
printf("%d\n", s.size() == 1 ? n - 1 : (n - 1 + s.size() - (cw | ch)));
return (0);
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
Β«PolygonΒ» is a system which allows to create programming tasks in a simple and professional way. When you add a test to the problem, the corresponding form asks you for the test index. As in most cases it is clear which index the next test will have, the system suggests the default value of the index. It is calculated as the smallest positive integer which is not used as an index for some previously added test.
You are to implement this feature. Create a program which determines the default index of the next test, given the indexes of the previously added tests.
Input
The first line contains one integer n (1 β€ n β€ 3000) β the amount of previously added tests. The second line contains n distinct integers a1, a2, ..., an (1 β€ ai β€ 3000) β indexes of these tests.
Output
Output the required default value for the next test index.
Examples
Input
3
1 7 2
Output
3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, najmniejsza = 1, poprzednia = 1;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
for (int i = 1; i <= n; i++) {
if (a[0] > 1) break;
if ((a[i] - 1) != poprzednia) {
poprzednia++;
break;
} else
poprzednia++;
}
cout << poprzednia;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
There are n shovels in the nearby shop. The i-th shovel costs a_i bourles.
Misha has to buy exactly k shovels. Each shovel can be bought no more than once.
Misha can buy shovels by several purchases. During one purchase he can choose any subset of remaining (non-bought) shovels and buy this subset.
There are also m special offers in the shop. The j-th of them is given as a pair (x_j, y_j), and it means that if Misha buys exactly x_j shovels during one purchase then y_j most cheapest of them are for free (i.e. he will not pay for y_j most cheapest shovels during the current purchase).
Misha can use any offer any (possibly, zero) number of times, but he cannot use more than one offer during one purchase (but he can buy shovels without using any offers).
Your task is to calculate the minimum cost of buying k shovels, if Misha buys them optimally.
Input
The first line of the input contains three integers n, m and k (1 β€ n, m β€ 2 β
10^5, 1 β€ k β€ min(n, 2000)) β the number of shovels in the shop, the number of special offers and the number of shovels Misha has to buy, correspondingly.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 β€ a_i β€ 2 β
10^5), where a_i is the cost of the i-th shovel.
The next m lines contain special offers. The j-th of them is given as a pair of integers (x_i, y_i) (1 β€ y_i β€ x_i β€ n) and means that if Misha buys exactly x_i shovels during some purchase, then he can take y_i most cheapest of them for free.
Output
Print one integer β the minimum cost of buying k shovels if Misha buys them optimally.
Examples
Input
7 4 5
2 5 4 2 6 3 1
2 1
6 5
2 1
3 1
Output
7
Input
9 4 8
6 8 5 1 8 1 1 2 1
9 2
8 4
5 3
9 7
Output
17
Input
5 1 4
2 5 7 4 6
5 4
Output
17
Note
In the first example Misha can buy shovels on positions 1 and 4 (both with costs 2) during the first purchase and get one of them for free using the first or the third special offer. And then he can buy shovels on positions 3 and 6 (with costs 4 and 3) during the second purchase and get the second one for free using the first or the third special offer. Then he can buy the shovel on a position 7 with cost 1. So the total cost is 4 + 2 + 1 = 7.
In the second example Misha can buy shovels on positions 1, 2, 3, 4 and 8 (costs are 6, 8, 5, 1 and 2) and get three cheapest (with costs 5, 1 and 2) for free. And then he can buy shovels on positions 6, 7 and 9 (all with costs 1) without using any special offers. So the total cost is 6 + 8 + 1 + 1 + 1 = 17.
In the third example Misha can buy four cheapest shovels without using any special offers and get the total cost 17.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3f;
const int MOD = 1e9 + 7;
const int N = 1e6 + 7;
int n, m, k, g[N];
long long a[N], pre[N], dp[N];
void Init() {
memset(g, 0, sizeof(g));
memset(dp, 0, sizeof(dp));
for (int i = (1); i < (n + 1); ++i) scanf("%I64d", a + i);
sort(a + 1, a + n + 1);
pre[0] = 0;
for (int i = (1); i < (n + 1); ++i) pre[i] = pre[i - 1] + a[i];
for (int i = (0); i < (m); ++i) {
int x, y;
scanf("%d%d", &x, &y);
g[x] = max(g[x], y);
}
}
int Solve() {
dp[0] = 0;
for (int i = (1); i < (k + 1); ++i)
for (int j = (0); j < (i); ++j) {
int t = g[i - j];
dp[i] = max(dp[i], dp[j] + pre[j + t] - pre[j]);
}
return printf("%I64d\n", pre[k] - dp[k]);
}
int main() {
while (~scanf("%d%d%d", &n, &m, &k)) {
Init();
Solve();
}
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
Petya loves lucky numbers. We all know that lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Petya wonders eagerly what minimum lucky number has the sum of digits equal to n. Help him cope with the task.
Input
The single line contains an integer n (1 β€ n β€ 106) β the sum of digits of the required lucky number.
Output
Print on the single line the result β the minimum lucky number, whose sum of digits equals n. If such number does not exist, print -1.
Examples
Input
11
Output
47
Input
10
Output
-1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (!(n % 7)) {
int x = n / 7;
while (x--) cout << '7';
return 0;
}
int aa = -1, bb = -1;
for (int a = 0; a < n; a++) {
int b = (n - a * 7) / 4;
if (b > 0)
if (b * 4 + a * 7 == n) {
if (aa == -1 || a + b < aa + bb || (a + b == aa + bb && aa < a)) aa = a;
bb = b;
}
}
if (aa != -1) {
while (bb--) cout << '4';
while (aa--) cout << '7';
} else
cout << -1 << endl;
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
Old timers of Summer Informatics School can remember previous camps in which each student was given a drink of his choice on the vechorka (late-evening meal). Or may be the story was more complicated?
There are n students living in a building, and for each of them the favorite drink a_i is known. So you know n integers a_1, a_2, ..., a_n, where a_i (1 β€ a_i β€ k) is the type of the favorite drink of the i-th student. The drink types are numbered from 1 to k.
There are infinite number of drink sets. Each set consists of exactly two portions of the same drink. In other words, there are k types of drink sets, the j-th type contains two portions of the drink j. The available number of sets of each of the k types is infinite.
You know that students will receive the minimum possible number of sets to give all students exactly one drink. Obviously, the number of sets will be exactly β n/2 β, where β x β is x rounded up.
After students receive the sets, they will distribute their portions by their choice: each student will get exactly one portion. Note, that if n is odd then one portion will remain unused and the students' teacher will drink it.
What is the maximum number of students that can get their favorite drink if β n/2 β sets will be chosen optimally and students will distribute portions between themselves optimally?
Input
The first line of the input contains two integers n and k (1 β€ n, k β€ 1 000) β the number of students in the building and the number of different drinks.
The next n lines contain student's favorite drinks. The i-th line contains a single integer from 1 to k β the type of the favorite drink of the i-th student.
Output
Print exactly one integer β the maximum number of students that can get a favorite drink.
Examples
Input
5 3
1
3
1
1
2
Output
4
Input
10 3
2
1
3
2
3
3
1
3
1
2
Output
9
Note
In the first example, students could choose three sets with drinks 1, 1 and 2 (so they will have two sets with two drinks of the type 1 each and one set with two drinks of the type 2, so portions will be 1, 1, 1, 1, 2, 2). This way all students except the second one will get their favorite drinks.
Another possible answer is sets with drinks 1, 2 and 3. In this case the portions will be 1, 1, 2, 2, 3, 3. Then all the students except one will gain their favorite drinks. The only student that will not gain the favorite drink will be a student with a_i = 1 (i.e. the first, the third or the fourth).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int m[1000];
int main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
m[a]++;
}
int x = (n / 2) + (n % 2);
int res = 0;
for (int i = 1; i < k + 1; i++) {
res += (m[i] / 2) * 2;
x -= m[i] / 2;
}
cout << res + x;
return 0;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
You are given circular array a0, a1, ..., an - 1. There are two types of operations with it:
* inc(lf, rg, v) β this operation increases each element on the segment [lf, rg] (inclusively) by v;
* rmq(lf, rg) β this operation returns minimal value on the segment [lf, rg] (inclusively).
Assume segments to be circular, so if n = 5 and lf = 3, rg = 1, it means the index sequence: 3, 4, 0, 1.
Write program to process given sequence of operations.
Input
The first line contains integer n (1 β€ n β€ 200000). The next line contains initial state of the array: a0, a1, ..., an - 1 ( - 106 β€ ai β€ 106), ai are integer. The third line contains integer m (0 β€ m β€ 200000), m β the number of operartons. Next m lines contain one operation each. If line contains two integer lf, rg (0 β€ lf, rg β€ n - 1) it means rmq operation, it contains three integers lf, rg, v (0 β€ lf, rg β€ n - 1; - 106 β€ v β€ 106) β inc operation.
Output
For each rmq operation write result for it. 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
4
1 2 3 4
4
3 0
3 0 -1
0 1
2 1
Output
1
0
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long n, m;
vector<long long> a;
long long t[1600000], lazy[1600000];
void build(int id, int l, int r) {
if (l == r) {
t[id] = a[l];
return;
}
int m = (l + r) / 2;
build(2 * id, l, m);
build(2 * id + 1, m + 1, r);
t[id] = min(t[2 * id], t[2 * id + 1]);
}
void push(int id, int l, int r) {
t[2 * id] += lazy[id];
t[2 * id + 1] += lazy[id];
lazy[2 * id] += lazy[id];
lazy[2 * id + 1] += lazy[id];
lazy[id] = 0;
}
void increase(int id, int l, int r, int x, int y, long long val) {
push(id, l, r);
if (x > r || y < l) return;
if (x <= l && y >= r) {
t[id] += val;
lazy[id] += val;
return;
}
int mid = (l + r) / 2;
increase(2 * id, l, mid, x, y, val);
increase(2 * id + 1, mid + 1, r, x, y, val);
t[id] = min(t[2 * id], t[2 * id + 1]);
}
long long query(int id, int l, int r, int x, int y) {
push(id, l, r);
if (x > r || y < l) return 1e9;
if (x <= l && y >= r) return t[id];
int m = (l + r) / 2;
long long p1 = query(2 * id, l, m, x, y);
long long p2 = query(2 * id + 1, m + 1, r, x, y);
return min(p1, p2);
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
long long temp;
cin >> temp;
a.push_back(temp);
}
build(1, 0, n - 1);
cin >> m;
while (m--) {
int l, r;
char c;
long long val;
scanf("%I64d %I64d%c", &l, &r, &c);
if (c != '\n') {
scanf("%lld", &val);
if (l > r) {
increase(1, 0, n - 1, l, n - 1, val);
increase(1, 0, n - 1, 0, r, val);
} else
increase(1, 0, n - 1, l, r, val);
} else {
if (l > r)
cout << min(query(1, 0, n - 1, l, n - 1), query(1, 0, n - 1, 0, r))
<< endl;
else
cout << query(1, 0, n - 1, l, r) << endl;
}
}
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
To make a paper airplane, one has to use a rectangular piece of paper. From a sheet of standard size you can make s airplanes.
A group of k people decided to make n airplanes each. They are going to buy several packs of paper, each of them containing p sheets, and then distribute the sheets between the people. Each person should have enough sheets to make n airplanes. How many packs should they buy?
Input
The only line contains four integers k, n, s, p (1 β€ k, n, s, p β€ 10^4) β the number of people, the number of airplanes each should make, the number of airplanes that can be made using one sheet and the number of sheets in one pack, respectively.
Output
Print a single integer β the minimum number of packs they should buy.
Examples
Input
5 3 2 3
Output
4
Input
5 3 100 1
Output
5
Note
In the first sample they have to buy 4 packs of paper: there will be 12 sheets in total, and giving 2 sheets to each person is enough to suit everyone's needs.
In the second sample they have to buy a pack for each person as they can't share sheets.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, a, b, c;
cin >> n >> a >> b >> c;
long long temp;
if (a % b == 0)
temp = a / b;
else
temp = a / b + 1;
long long te = n * temp;
if (te % c == 0)
cout << te / c;
else
cout << te / c + 1;
return 0;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
You are given two strings s and t consisting of small Latin letters, string s can also contain '?' characters.
Suitability of string s is calculated by following metric:
Any two letters can be swapped positions, these operations can be performed arbitrary number of times over any pair of positions. Among all resulting strings s, you choose the one with the largest number of non-intersecting occurrences of string t. Suitability is this number of occurrences.
You should replace all '?' characters with small Latin letters in such a way that the suitability of string s is maximal.
Input
The first line contains string s (1 β€ |s| β€ 106).
The second line contains string t (1 β€ |t| β€ 106).
Output
Print string s with '?' replaced with small Latin letters in such a way that suitability of that string is maximal.
If there are multiple strings with maximal suitability then print any of them.
Examples
Input
?aa?
ab
Output
baab
Input
??b?
za
Output
azbz
Input
abcd
abacaba
Output
abcd
Note
In the first example string "baab" can be transformed to "abab" with swaps, this one has suitability of 2. That means that string "baab" also has suitability of 2.
In the second example maximal suitability you can achieve is 1 and there are several dozens of such strings, "azbz" is just one of them.
In the third example there are no '?' characters and the suitability of the string is 0.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
map<char, int> freq;
string a, b;
vector<int> v;
int main() {
cin >> a >> b;
for (int i = 0; a[i]; ++i) {
if (a[i] == '?')
v.push_back(i);
else
freq[a[i]]++;
}
int i = 0;
while (i < v.size()) {
for (auto j : b) {
if (freq[j] > 0) {
freq[j]--;
} else {
a[v[i]] = j;
i++;
if (i == v.size()) break;
}
}
}
cout << a << endl;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
We have a sequence of N integers: x=(x_0,x_1,\cdots,x_{N-1}). Initially, x_i=0 for each i (0 \leq i \leq N-1).
Snuke will perform the following operation exactly M times:
* Choose two distinct indices i, j (0 \leq i,j \leq N-1,\ i \neq j). Then, replace x_i with x_i+2 and x_j with x_j+1.
Find the number of different sequences that can result after M operations. Since it can be enormous, compute the count modulo 998244353.
Constraints
* 2 \leq N \leq 10^6
* 1 \leq M \leq 5 \times 10^5
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
Output
Print the number of different sequences that can result after M operations, modulo 998244353.
Examples
Input
2 2
Output
3
Input
3 2
Output
19
Input
10 10
Output
211428932
Input
100000 50000
Output
3463133
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
const int maxn=4001000,mod=998244353;
inline void Add(int &a,int b){a=a+b>=mod?a+b-mod:a+b;}
inline int ksm(int a,int b)
{
int res=1;
for(;b;b>>=1,a=1ll*a*a%mod) if(b&1) res=1ll*res*a%mod;
return res;
}
int fac[maxn],invfac[maxn];
inline int C(int n,int m){return 1ll*fac[n]*invfac[m]%mod*invfac[n-m]%mod;}
int n,m;
inline int cal(int n,int m,int lim)
{
int ans=0;
for(int i=0;i<=min(n,lim);i++) if(!((m-i)&1))
Add(ans,1ll*C(n,i)*C((m-i)/2+n-1,n-1)%mod);
return ans;
}
int main()
{
for(int i=fac[0]=1;i<maxn;i++) fac[i]=1ll*fac[i-1]*i%mod;
invfac[maxn-1]=ksm(fac[maxn-1],mod-2);
for(int i=maxn-2;i>=0;i--) invfac[i]=1ll*invfac[i+1]*(i+1)%mod;
cin>>n>>m;printf("%lld\n",(cal(n,3*m,m)-1ll*n*cal(n,m,m)%mod+1ll*n*cal(n-1,m,m)%mod+mod)%mod);
return 0;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
A one-dimensional Japanese crossword can be represented as a binary string of length x. An encoding of this crossword is an array a of size n, where n is the number of segments formed completely of 1's, and ai is the length of i-th segment. No two segments touch or intersect.
For example:
* If x = 6 and the crossword is 111011, then its encoding is an array {3, 2};
* If x = 8 and the crossword is 01101010, then its encoding is an array {2, 1, 1};
* If x = 5 and the crossword is 11111, then its encoding is an array {5};
* If x = 5 and the crossword is 00000, then its encoding is an empty array.
Mishka wants to create a new one-dimensional Japanese crossword. He has already picked the length and the encoding for this crossword. And now he needs to check if there is exactly one crossword such that its length and encoding are equal to the length and encoding he picked. Help him to check it!
Input
The first line contains two integer numbers n and x (1 β€ n β€ 100000, 1 β€ x β€ 109) β the number of elements in the encoding and the length of the crossword Mishka picked.
The second line contains n integer numbers a1, a2, ..., an (1 β€ ai β€ 10000) β the encoding.
Output
Print YES if there exists exaclty one crossword with chosen length and encoding. Otherwise, print NO.
Examples
Input
2 4
1 3
Output
NO
Input
3 10
3 3 2
Output
YES
Input
2 10
1 3
Output
NO
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
long long x;
cin >> n >> x;
long long sum = 0;
for (int i = 1; i <= n; i++) {
int tmp;
cin >> tmp;
sum += (tmp + 1);
}
sum--;
if (sum == x)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
There are N strings of lowercase alphabet only. The i-th string is S_i. Every string is unique.
Provide answers for the Q queries below. The i-th query has the following format:
Query: An integer k_i and a string p_{i,1}p_{i,2}...p_{i,26} that results from permuting {`a`,`b`,...,`z`} are given. Output the sequence of the string S_{k_i} among the N strings in lexicographical order when the literal sequence is p_{i,1}<p_{i,2}<...<p_{i,26}.
Constraints
* 1 β¦ N,Q β¦ 100000
* 1 β¦ |S_i| (1 β¦ i β¦ N)
* S_i (1 β¦ i β¦ N) is a string of lowercase alphabet.
* The sum of |S_i| is no more than 400000.
* Every S_i is unique.
* 1 β¦ k_i β¦ N (1 β¦ i β¦ Q)
* For all 1 β¦ i β¦ Q, p_{i,1}p_{i,2}...p_{i,26} is a permutation of `abcd...z`.
Input
Inputs are provided from standard inputs in the following form.
N
S_1
:
S_N
Q
k_1 p_{1,1}p_{1,2}...p_{1,26}
:
k_Q p_{Q,1}p_{Q,2}...p_{Q,26}
Output
Output Q lines.
On line i, for the i-th query, output an integer indicating the sequence of the string S_{k_i} among the N strings in lexicographical order.
Examples
Input
5
aa
abbaa
abbba
aaab
aaaaaba
5
1 abcdefghijklmnopqrstuvwxyz
2 bacdefghijklmnopqrstuvwxyz
3 abcdefghijklmnopqrstuvwxyz
4 bacdefghijklmnopqrstuvwxyz
5 abcdefghijklmnopqrstuvwxyz
Output
1
2
5
4
2
Input
8
abrakatabra
abadaba
abracadabra
atcoder
grand
contest
ababa
a
6
3 abcdefghijklmnopqrstuvwxyz
6 qwertyuiopasdfghjklzxcvbnm
8 poiuytrewqlkjhgfdsamnbvcxz
2 qazwsxedcrfvtgbyhnujmikolp
1 plokmijnuhbygvtfcrdxeszwaq
4 mnbvcxzasdfghjklpoiuytrewq
Output
4
8
2
3
4
7
### Response
```cpp
//Link : https://atcoder.jp/contests/code-festival-2016-qualb/tasks/codefestival_2016_qualB_e
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define N 400002
#define ALP 26
#define mod 1000000007
int terminal[N];
int nextNode[N][ALP],cc[N];
int alwaysWin[N];
int triePos = 1;
int relation[N][ALP][ALP];
int globalValue[ALP][ALP];
void traverse(int node,char *s,int pos,int id) {
++cc[node];
if(s[pos]==0) {
terminal[node] = id;
return;
}
int alp = s[pos]-'a';
++pos;
if(nextNode[node][alp]==0) {
nextNode[node][alp] = triePos++;
}
traverse(nextNode[node][alp],s,pos,id);
}
void precompute(int root,int alreadyLoseNumber) {
int ter = terminal[root];
if(ter!=0) {
alwaysWin[ter] += alreadyLoseNumber;
for(int i=0;i<26;++i) {
for(int j=0;j<26;++j) {
if(i!=j) {
relation[ter][i][j] += globalValue[i][j];
}
}
}
++alreadyLoseNumber;
}
int tmp[ALP];
for(int i=0;i<26;++i) {
tmp[i] = 0;
}
for(int i=0;i<26;++i) {
int node = nextNode[root][i];
if(node==0) {
continue;
}
tmp[i] = cc[node];
}
for(int i=0;i<26;++i) {
int node = nextNode[root][i];
if(node==0) {
continue;
}
for(int k=0;k<26;++k) {
if(i!=k) {
globalValue[i][k] += tmp[k];
}
}
precompute(node,alreadyLoseNumber);
for(int k=0;k<26;++k) {
if(i!=k) {
globalValue[i][k] -= tmp[k];
}
}
}
}
char tmp[N];
int ord[N];
void solve(){
int n;scanf("%d ", &n);
for(int i=1;i<=n;++i) {
scanf("%s ", tmp);
traverse(0,tmp,0,i);
}
precompute(0,0);
int q;scanf("%d ", &q);
while(q--) {
int k;scanf("%d %s ", &k,tmp);
for(int i=0;i<26;++i) {
ord[tmp[i]-'a'] = i;
}
int r = 1 + alwaysWin[k];
for(int i=0;i<26;++i) {
for(int j=0;j<26;++j) {
if(i==j) {
continue;
}
if(ord[i]>ord[j]) {
r += relation[k][i][j];
}
}
}
printf("%d\n", r);
}
}
int main() {
//freopen("input.txt","r",stdin);
solve();
return 0;
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
I decided to move and decided to leave this place. There is nothing wrong with this land itself, but there is only one thing to worry about. It's a plum tree planted in the garden. I was looking forward to this plum blooming every year. After leaving here, the fun of spring will be reduced by one. Wouldn't the scent of my plums just take the wind and reach the new house to entertain spring?
There are three flowers that symbolize spring in Japan. There are three, plum, peach, and cherry blossom. In addition to my plum blossoms, the scent of these flowers will reach my new address. However, I would like to live in the house where only the scent of my plums arrives the most days.
<image>
As shown in the figure, the scent of flowers spreads in a fan shape, and the area is determined by the direction and strength of the wind. The sector spreads symmetrically around the direction w of the wind, and has a region whose radius is the strength of the wind a. The angle d at which the scent spreads is determined by the type of flower, but the direction and strength of the wind varies from day to day. However, on the same day, the direction and strength of the wind is the same everywhere.
At hand, I have data on the positions of plums, peaches, and cherry blossoms other than my plums, the angle at which the scent spreads for each type of flower, and the candidate homes to move to. In addition, there are data on the direction and strength of the wind for several days. The positions of plums, peaches, cherry trees and houses other than my plums are shown in coordinates with the position of my plums as the origin.
Let's use these data to write a program to find the house with the most days when only my plum scent arrives. Because I'm a talented programmer!
input
The input consists of multiple datasets. The end of the input is indicated by two lines of zeros. Each dataset is given in the following format:
H R
hx1 hy1
hx2 hy2
::
hxH hyH
U M S du dm ds
ux1 uy1
ux2 uy2
::
uxU uyU
mx1 my1
mx2 my2
::
mxM myM
sx1 sy1
sx2 sy2
::
sxS syS
w1 a1
w2 a2
::
wR aR
The numbers given on each line are separated by a single space.
The first line gives the number of candidate homes to move to H (1 β€ H β€ 100) and the number of wind records R (1 β€ R β€ 100). The following line H is given the location of the new house. hxi and hyi are integers between -1000 and 1000 that indicate the x and y coordinates of the i-th house.
In the next line, the number U of plum trees other than my plum and the number of peach / cherry trees M, S, and the angles du, dm, and ds that spread the scent of plum / peach / cherry are given. The range of U, M, and S is 0 or more and 10 or less. The unit of angle is degrees, which is an integer greater than or equal to 1 and less than 180. The following U line gives the position of the plum tree other than my plum, the following M line gives the position of the peach tree, and the following S line gives the position of the cherry tree. uxi and uyi, mxi and myi, sxi and syi are integers between -1000 and 1000, indicating the x and y coordinates of the i-th plum, peach, and cherry tree, respectively.
The following R line is given a record of the wind. wi (0 β€ wi <360) and ai (0 <ai β€ 100) are integers representing the direction and strength of the wind on day i. The direction of the wind is expressed as an angle measured counterclockwise from the positive direction of the x-axis, and the unit is degrees.
The input may be considered to satisfy the following conditions.
* All coordinates entered shall be different.
* There is nothing but my plum at the origin.
* For any flower, there is no house within 0.001 distance from the boundary of the area where the scent of the flower reaches.
The number of datasets does not exceed 50.
output
For each dataset, print the numbers of all the houses with the most days that only my plum scent arrives on one line in ascending order. Separate the house numbers with a single space. Do not print whitespace at the end of the line.
However, for any house, if there is no day when only the scent of my plum blossoms arrives, it will be output as NA.
Example
Input
6 3
2 1
1 2
5 2
1 3
1 5
-2 3
1 1 1 90 30 45
3 -4
-3 0
2 -2
45 6
90 6
135 6
2 1
1 3
5 2
0 1 1 90 30 45
-3 0
2 -2
45 6
0 0
Output
5 6
NA
### Response
```cpp
#include <cstdio>
#include <cmath>
#include <cfloat>
#include <cstring>
#include <cassert>
#include <vector>
#include <algorithm>
using namespace std;
/* double extention Library. */
const double EPS = 1e-8;
bool eq(double a, double b)
{
return (fabs(a - b) <= EPS);
}
bool lt(double a, double b)
{
return (a - b < EPS);
}
bool leq(double a, double b)
{
return (lt(a, b) || eq(a, b));
}
bool gt(double a, double b)
{
return (a - b > -EPS);
}
bool geq(double a, double b)
{
return (gt(a, b) || eq(a, b));
}
/* 2-D Geometry Library. */
class Point{
public:
double x, y;
Point (double x = 0, double y = 0): x(x), y(y){}
Point operator + (Point p){
return (Point(x + p.x, y + p.y));
}
Point operator - (Point p){
return (Point(x - p.x, y - p.y));
}
Point operator * (double a){
return (Point(x * a, y * a));
}
double abs(){
return (sqrt(norm()));
}
double norm(){
return (x * x + y * y);
}
bool operator < (const Point &p) const {
return (x != p.x ? x < p.x : y < p.y);
}
bool operator == (const Point &p) const {
return (fabs(x - p.x) < EPS && fabs(y - p.y) < EPS);
}
bool operator != (const Point &p) const {
return (!(*this == p));
}
};
typedef Point Vector;
typedef vector<Point> Polygon;
double norm(Vector a)
{
return (a.x * a.x + a.y * a.y);
}
double abs(Vector a)
{
return (sqrt(norm(a)));
}
double dot(Vector a, Vector b)
{
return (a.x * b.x + a.y * b.y);
}
double cross(Vector a, Vector b)
{
return (a.x * b.y - a.y * b.x);
}
static const int COUNTER_CLOCKWISE = 1;
static const int CLOCKWISE = -1;
static const int ONLINE_BACK = 2;
static const int ONLINE_FRONT = -2;
static const int ON_SEGMENT = 0;
int ccw(Point p0, Point p1, Point p2){
Vector a = p1 - p0;
Vector b = p2 - p0;
if (cross(a, b) > EPS) return (COUNTER_CLOCKWISE);
if (cross(a, b) < -EPS) return (CLOCKWISE);
if (dot(a, b) < -EPS) return (ONLINE_BACK);
if (norm(a) < norm(b)) return (ONLINE_FRONT);
return (ON_SEGMENT);
}
bool isIntersect(Point p1, Point p2, Point p3, Point p4){
return (ccw(p1, p2, p3) * ccw(p1, p2, p4) <= 0 &&
ccw(p3, p4, p1) * ccw(p3, p4, p2) <= 0 );
}
bool isInside(Polygon gon, Point p)
{
for (int i = 0; i < gon.size(); i++){
if (ccw(gon[i], gon[(i + 1) % gon.size()], p) == CLOCKWISE) return (false);
}
return (true);
}
Point unitVector(Vector t)
{
double u = abs(t);
return (Point(t.x / u , t.y / u));
}
double getCos(Vector a, Vector b)
{
return (dot(a, b) / (abs(a) * abs(b)));
}
double getSin(Point a , Point b)
{
double t = getCos(a, b);
return (sqrt(1.0 - t * t));
}
double getArg(Vector v)
{
return (atan2(v.y, v.x));
}
double getDistPL(Point p, Point a, Point b)
{
return (fabs(cross(b - a, p - a)) / abs(b - a));
}
double getDistPS(Point p, Point a, Point b)
{
if(dot(b - a, p - a) < EPS) return (abs(p - a));
if(dot(a - b, p - b) < EPS) return (abs(p - b));
return (getDistPL(p, a, b));
}
Point interPointS(Point a1 , Point a2 , Point b1 , Point b2)
{
Point b = b2 - b1;
double d1 = fabs(cross(b, a1 - b1));
double d2 = fabs(cross(b, a2 - b1));
double t = d1 / (d1 + d2);
Point a = a2 - a1;
Point v = a * t;
return (a1 + v);
}
Point interPointL(Point a1 , Point a2 , Point b1 , Point b2)
{
Point a = a2 - a1;
Point b = b2 - b1;
double t = cross(b, b1 - a1) / cross(b, a);
Point v = a * t;
return (a1 + v);
}
void interPointLC(Point a, Point b, Point c, double r, Point ans[])
{
if (getDistPL(c, a, b) > r + EPS) return;
Point v = unitVector(b - a);
double delta = dot(v, a - c) * dot(v, a - c) - abs(a - c) * abs(a - c) + r * r;
double t = -dot(v, a - c);
double s = sqrt(delta);
ans[0] = a + v * (t + s);
ans[1] = a + v * (t - s);
}
Point xTranslate(Point t, double k)
{
return (Point(t.x, 2 * k - t.y));
}
Point yTranslate(Point t, double k)
{
return (Point(2 * k - t.x, t.y));
}
Point oTranslate(Point t, Point k)
{
return (k + (k - t));
}
Point rotate(Point t , Point p , double r)
{
double ta=cos(r)*(t.x-p.x)-sin(r)*(t.y-p.y)+p.x;
double tb=sin(r)*(t.x-p.x)+cos(r)*(t.y-p.y)+p.y;
return Point(ta , tb);
}
void interPointCC(Point a , double ra , Point b , double rb , Point ans[])
{
double di=fabs(abs(a-b));
if(di > ra+rb || di < fabs(ra-rb)) return;
double t=(ra*ra-rb*rb+di*di)/(di+di);
double rd=acos(t/ra);
Point dv=unitVector(b-a);
Point g1=rotate(dv , Point(0,0) , rd);
Point g2=rotate(dv , Point(0,0) , -rd);
ans[0]=a+g1*ra;
ans[1]=a+g2*ra;
}
Point normalVector(Point p,Point a,Point b)
{
Point v=unitVector(b-a);
v = cross(v , p-a) > 0 ? Point(v.y,(-1)*v.x) : Point((-1)*v.y , v.x);
return v*getDistPL(p,a,b);
}
Point fTranslate(Point t , Point a , Point b)
{
return t+normalVector(t,a,b)*2;
}
double area(Point a, Point b, Point c){
return fabs(cross(c-a , b-a)*0.5);
}
double polygonArea(Polygon t){
double ans = 0.0;
for (unsigned int i = 0; i < t.size(); i++)
ans += cross(t[i] , t[(i + 1) % t.size()]);
return (ans / 2);
}
Polygon conhel(Polygon& ps)
{
sort(ps.begin(), ps.end());
int k = 0, n = static_cast<int>(ps.size());
Polygon qs(n * 2);
for (int i = 0; i < n; i++){
while (k > 1 && cross(qs[k - 1] - qs[k - 2], ps[i] - qs[k - 1]) < EPS) k--;
qs[k++] = ps[i];
}
for (int i = n - 2, t = k; i >= 0; i--){
while (k > t && cross(qs[k - 1] - qs[k - 2], ps[i] - qs[k - 1]) < EPS) k--;
qs[k++] = ps[i];
}
qs.resize(k - 1);
return (qs);
}
bool isIn(Point center, Point target, double arg, double arg2, double len)
{
if (gt(abs(target - center), len)) return (false);
Point p1 = Point(center.x + len * cos(arg - arg2 / 2), center.y + len * sin(arg - arg2 / 2)),
p2 = Point(center.x + len * cos(arg + arg2 / 2), center.y + len * sin(arg + arg2 / 2));
return (ccw(p1, center, target) == CLOCKWISE && ccw(p2, center, target) == COUNTER_CLOCKWISE);
}
int main()
{
int H, R;
int U, M, S, du, dm, ds;
int cnt[128];
Point house[128], up[16], mp[16], sp[16];
while (scanf("%d %d", &H, &R) && H){
for (int i = 0; i < H; i++) scanf("%lf %lf", &house[i].x, &house[i].y);
scanf("%d %d %d %d %d %d", &U, &M, &S, &du, &dm, &ds);
for (int i = 0; i < U; i++) scanf("%lf %lf", &up[i].x, &up[i].y);
for (int i = 0; i < M; i++) scanf("%lf %lf", &mp[i].x, &mp[i].y);
for (int i = 0; i < S; i++) scanf("%lf %lf", &sp[i].x, &sp[i].y);
memset(cnt, 0 ,sizeof(cnt));
int ma = 0;
for (int i = 0; i < R; i++){
int rad, size;
scanf("%d %d", &rad, &size);
for (int j = 0; j < H; j++){
bool ok = isIn(Point(0, 0), house[j], rad * M_PI / 180.0, du * M_PI / 180.0, size);
for (int k = 0; k < U; k++) ok &= !isIn(up[k], house[j], rad * M_PI / 180.0, du * M_PI / 180.0, size);
for (int k = 0; k < M; k++) ok &= !isIn(mp[k], house[j], rad * M_PI / 180.0, dm * M_PI / 180.0, size);
for (int k = 0; k < S; k++) ok &= !isIn(sp[k], house[j], rad * M_PI / 180.0, ds * M_PI / 180.0, size);
cnt[j] += ok;
if (cnt[j] > ma) ma = cnt[j];
}
}
if (!ma) printf("NA\n");
else {
bool printed = false;
for (int i = 0; i < H; i++){
if (cnt[i] == ma){
if (printed) printf(" ");
printf("%d", i + 1);
printed = true;
}
}
printf("\n");
}
}
return (0);
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
Lindsey Buckingham told Stevie Nicks ["Go your own way"](https://www.youtube.com/watch?v=6ul-cZyuYq4). Nicks is now sad and wants to go away as quickly as possible, but she lives in a 2D hexagonal world.
Consider a hexagonal tiling of the plane as on the picture below.
<image>
Nicks wishes to go from the cell marked (0, 0) to a certain cell given by the coordinates. She may go from a hexagon to any of its six neighbors you want, but there is a cost associated with each of them. The costs depend only on the direction in which you travel. Going from (0, 0) to (1, 1) will take the exact same cost as going from (-2, -1) to (-1, 0). The costs are given in the input in the order c_1, c_2, c_3, c_4, c_5, c_6 as in the picture below.
<image>
Print the smallest cost of a path from the origin which has coordinates (0, 0) to the given cell.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 10^{4}). Description of the test cases follows.
The first line of each test case contains two integers x and y (-10^{9} β€ x, y β€ 10^{9}) representing the coordinates of the target hexagon.
The second line of each test case contains six integers c_1, c_2, c_3, c_4, c_5, c_6 (1 β€ c_1, c_2, c_3, c_4, c_5, c_6 β€ 10^{9}) representing the six costs of the making one step in a particular direction (refer to the picture above to see which edge is for each value).
Output
For each testcase output the smallest cost of a path from the origin to the given cell.
Example
Input
2
-3 1
1 3 5 7 9 11
1000000000 1000000000
1000000000 1000000000 1000000000 1000000000 1000000000 1000000000
Output
18
1000000000000000000
Note
The picture below shows the solution for the first sample. The cost 18 is reached by taking c_3 3 times and c_2 once, amounting to 5+5+5+3=18.
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 5;
long long x, y;
long long a[10];
vector<long long> dx = {1, 0, -1, -1, 0, 1};
vector<long long> dy = {1, 1, 0, -1, -1, 0};
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long t;
cin >> t;
while (t--) {
cin >> x >> y;
for (long long i = 0; i < 6; i++) cin >> a[i];
for (long long i = 1; i <= 100; i++)
for (long long j = 0; j < 6; j++)
a[j] = min(a[j], a[(j - 1 + 6) % 6] + a[(j + 1) % 6]);
long long ans = 4e18;
for (long long i = 0; i < 6; i++) {
long long rx = x, ry = y;
long long take = 2e9;
if (dx[i] != 0) take = rx / dx[i];
if (dy[i] != 0) take = min(take, ry / dy[i]);
if (take < 0) take = take * (-1);
rx -= take * dx[i];
ry -= take * dy[i];
long long curCost = take * a[i];
long long cx = rx, cy = ry;
for (long long j = 0; j < 6; j++) {
long long rx = cx, ry = cy;
long long take = 2e9;
if (dx[j] != 0) take = rx / dx[j];
if (dy[j] != 0) take = min(take, ry / dy[j]);
if (take < 0) take = take * (-1);
rx -= take * dx[j];
ry -= take * dy[j];
if (rx == 0 && ry == 0) ans = min(ans, curCost + take * a[j]);
}
}
cout << ans << "\n";
}
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
You have a string A = A_1 A_2 ... A_n consisting of lowercase English letters.
You can choose any two indices i and j such that 1 \leq i \leq j \leq n and reverse substring A_i A_{i+1} ... A_j.
You can perform this operation at most once.
How many different strings can you obtain?
Constraints
* 1 \leq |A| \leq 200,000
* A consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
A
Output
Print the number of different strings you can obtain by reversing any substring in A at most once.
Examples
Input
aatt
Output
5
Input
xxxxxxxxxx
Output
1
Input
abracadabra
Output
44
### Response
```cpp
#include<iostream>
#include<cstdio>
#include<cstring>
#define ll long long
using namespace std;
ll ans,cnt[30];
char s[200010];
int main()
{
scanf("%s",s);
ll len=strlen(s);
ans=(len-1)*len/2+1;
for(int i=0;i<len;i++) cnt[s[i]-'a']++;
for(int i=0;i<26;i++) ans-=cnt[i]*(cnt[i]-1)/2;
printf("%lld",ans);
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
You are given two strings A and B representing essays of two students who are suspected cheaters. For any two strings C, D we define their similarity score S(C,D) as 4β
LCS(C,D) - |C| - |D|, where LCS(C,D) denotes the length of the Longest Common Subsequence of strings C and D.
You believe that only some part of the essays could have been copied, therefore you're interested in their substrings.
Calculate the maximal similarity score over all pairs of substrings. More formally, output maximal S(C, D) over all pairs (C, D), where C is some substring of A, and D is some substring of B.
If X is a string, |X| denotes its length.
A string a is a substring of a string b if a can be obtained from b by deletion of several (possibly, zero or all) characters from the beginning and several (possibly, zero or all) characters from the end.
A string a is a subsequence of a string b if a can be obtained from b by deletion of several (possibly, zero or all) characters.
Pay attention to the difference between the substring and subsequence, as they both appear in the problem statement.
You may wish to read the [Wikipedia page about the Longest Common Subsequence problem](https://en.wikipedia.org/wiki/Longest_common_subsequence_problem).
Input
The first line contains two positive integers n and m (1 β€ n, m β€ 5000) β lengths of the two strings A and B.
The second line contains a string consisting of n lowercase Latin letters β string A.
The third line contains a string consisting of m lowercase Latin letters β string B.
Output
Output maximal S(C, D) over all pairs (C, D), where C is some substring of A, and D is some substring of B.
Examples
Input
4 5
abba
babab
Output
5
Input
8 10
bbbbabab
bbbabaaaaa
Output
12
Input
7 7
uiibwws
qhtkxcn
Output
0
Note
For the first case:
abb from the first string and abab from the second string have LCS equal to abb.
The result is S(abb, abab) = (4 β
|abb|) - |abb| - |abab| = 4 β
3 - 3 - 4 = 5.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using ld = long double;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<ll>;
using vvl = vector<vl>;
int n, m;
string A, B;
string a, b;
vvi dp;
vvi from;
int f(int i, int j) {
if (i >= n or j >= m) return 0;
int& ans = dp[i][j];
if (ans != -1) return ans;
ans = 0;
if (a[i] == b[j]) ans = max(ans, max(4, f(i + 1, j + 1) + 2));
ans = max(ans, f(i + 1, j) - 1);
ans = max(ans, f(i, j + 1) - 1);
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
cin >> A >> B;
n = A.size();
m = B.size();
a = A;
b = B;
dp = vvi(n, vi(m, -1));
from = vvi(n, vi(m, -1));
int ans = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
ans = max(ans, f(i, j) - 2);
}
}
cout << ans << '\n';
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
Nathan O. Davis is trying to capture a game and struggling to get a very rare item. This rare item can be obtained by arranging special patterns in a row on a casino slot machine. The slot machine has N reels, and pressing the button once stops the currently rotating leftmost reel. Therefore, you need to press the button N times to get this rare item. Also, in order to stop with a special pattern, it is necessary to press the button at a certain timing. However, the timing of pressing this button was very severe, so I was in trouble because it didn't go well. Therefore, Nathan decided to analyze the game while checking the memory value during the game using the memory viewer.
As a result of Nathan's analysis, in order to stop the reel with that special pattern, the "random number" written at address 007E0D1F in the memory must have a specific value when the button is pressed. I found out. It was also found that the value of the random number changes every frame by the linear congruential method, and whether or not the button is pressed is judged once every frame. Here, the linear congruential method is one of the methods for generating pseudo-random numbers, and the value is determined by the following formula.
x'= (A x x + B) mod C
Here, x is the value of the current random number, x'is the value of the next random number, and A, B, and C are some constants. Also, y mod z represents the remainder when y is divided by z.
For example, suppose a slot machine with two reels has A = 5, B = 7, C = 11 and the first "random number" value is 10. And, the condition for stopping the reel with a special pattern is that the reel on the left side is 2 and the reel on the right side is 4. At this time, the value of the random number in the first frame is (5 Γ 10 + 7) mod 11 = 2, so if you press the button in the first frame, the reel on the left side will stop with a special pattern. Since the value of the random number in the second frame that follows is (5 x 2 + 7) mod 11 = 6, the reel on the right side does not stop with a special pattern even if the button is pressed in the second frame. In the following 3rd frame, the random number value becomes (5 x 6 + 7) mod 11 = 4, so if you press the button in the 3rd frame, the reel on the right side will stop with a special pattern. Therefore, all reels can be stopped with a special pattern in a minimum of 3 frames, and rare items can be obtained.
Your job is to help Nathan get a rare item by writing a program that asks how many frames in the shortest frame all reels can be stopped with a special pattern. ..
Input
The input consists of multiple datasets. Each dataset is given in the following format.
> N A B C X
> Y1 Y2 ... YN
The first row contains five integers N (1 β€ N β€ 100), A, B (0 β€ A, B β€ 10,000), C (1 β€ C β€ 10,000), and X (0 β€ X <C), respectively. It is given separated by two whitespace characters. Here, X represents the value of the first random number. On the following line, N integers Y1, Y2, ..., YN (0 β€ Yi β€ 10,000) are given, separated by a single space character. These represent the conditions for stopping the reel with a specific pattern, and the i-th number Yi is the random number value Yi to stop the i-th reel from the left with a special pattern. It means that there must be.
The end of the input is indicated by a single line containing five zeros separated by blanks.
Output
For each dataset, output the shortest number of frames required to stop at a special pattern on one line. If it cannot be stopped within 10,000 frames, output -1 instead of the number of frames. The output must not contain extra blanks or line breaks.
Sample Input
1 5 7 11 10
Ten
2 5 7 11 10
twenty four
2 1 1 256 0
128 255
2 0 0 1 0
1 2 3 4 5 6 7 8
2 1 1 100 0
99 98
2 1 1 100 0
99 99
2 1 1 10000 0
Ten
2 1 1 10000 0
twenty one
0 0 0 0 0
Output for the Sample Input
0
3
255
-1
198
199
10000
-1
Example
Input
1 5 7 11 10
10
2 5 7 11 10
2 4
2 1 1 256 0
128 255
2 0 0 1 0
1234 5678
2 1 1 100 0
99 98
2 1 1 100 0
99 99
2 1 1 10000 0
1 0
2 1 1 10000 0
2 1
0 0 0 0 0
Output
0
3
255
-1
198
199
10000
-1
### Response
```cpp
#include<cstdio>
using namespace std;
int main(){
for(int n,a,b,c,x;scanf("%d%d%d%d%d",&n,&a,&b,&c,&x),n;){
int y[100];
for(int i=0;i<n;i++) scanf("%d",y+i);
bool ok=false;
int t,pos=0;
for(t=0;t<=10000;t++){
if(x==y[pos]) pos++;
if(pos==n){ ok=true; break; }
x=(a*x+b)%c;
}
if(ok) printf("%d\n",t);
else puts("-1");
}
return 0;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
There is an infinite line consisting of cells. There are n boxes in some cells of this line. The i-th box stands in the cell a_i and has weight w_i. All a_i are distinct, moreover, a_{i - 1} < a_i holds for all valid i.
You would like to put together some boxes. Putting together boxes with indices in the segment [l, r] means that you will move some of them in such a way that their positions will form some segment [x, x + (r - l)].
In one step you can move any box to a neighboring cell if it isn't occupied by another box (i.e. you can choose i and change a_i by 1, all positions should remain distinct). You spend w_i units of energy moving the box i by one cell. You can move any box any number of times, in arbitrary order.
Sometimes weights of some boxes change, so you have queries of two types:
1. id nw β weight w_{id} of the box id becomes nw.
2. l r β you should compute the minimum total energy needed to put together boxes with indices in [l, r]. Since the answer can be rather big, print the remainder it gives when divided by 1000 000 007 = 10^9 + 7. Note that the boxes are not moved during the query, you only should compute the answer.
Note that you should minimize the answer, not its remainder modulo 10^9 + 7. So if you have two possible answers 2 β
10^9 + 13 and 2 β
10^9 + 14, you should choose the first one and print 10^9 + 6, even though the remainder of the second answer is 0.
Input
The first line contains two integers n and q (1 β€ n, q β€ 2 β
10^5) β the number of boxes and the number of queries.
The second line contains n integers a_1, a_2, ... a_n (1 β€ a_i β€ 10^9) β the positions of the boxes. All a_i are distinct, a_{i - 1} < a_i holds for all valid i.
The third line contains n integers w_1, w_2, ... w_n (1 β€ w_i β€ 10^9) β the initial weights of the boxes.
Next q lines describe queries, one query per line.
Each query is described in a single line, containing two integers x and y. If x < 0, then this query is of the first type, where id = -x, nw = y (1 β€ id β€ n, 1 β€ nw β€ 10^9). If x > 0, then the query is of the second type, where l = x and r = y (1 β€ l_j β€ r_j β€ n). x can not be equal to 0.
Output
For each query of the second type print the answer on a separate line. Since answer can be large, print the remainder it gives when divided by 1000 000 007 = 10^9 + 7.
Example
Input
5 8
1 2 6 7 10
1 1 1 1 2
1 1
1 5
1 3
3 5
-3 5
-1 10
1 4
2 5
Output
0
10
3
4
18
7
Note
Let's go through queries of the example:
1. 1\ 1 β there is only one box so we don't need to move anything.
2. 1\ 5 β we can move boxes to segment [4, 8]: 1 β
|1 - 4| + 1 β
|2 - 5| + 1 β
|6 - 6| + 1 β
|7 - 7| + 2 β
|10 - 8| = 10.
3. 1\ 3 β we can move boxes to segment [1, 3].
4. 3\ 5 β we can move boxes to segment [7, 9].
5. -3\ 5 β w_3 is changed from 1 to 5.
6. -1\ 10 β w_1 is changed from 1 to 10. The weights are now equal to w = [10, 1, 5, 1, 2].
7. 1\ 4 β we can move boxes to segment [1, 4].
8. 2\ 5 β we can move boxes to segment [5, 8].
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void chmin(T &x, const T &y) {
if (x > y) x = y;
}
template <typename T>
void chmax(T &x, const T &y) {
if (x < y) x = y;
}
int read() {
char c;
while ((c = getchar()) < '-')
;
if (c == '-') {
int x = (c = getchar()) - '0';
while ((c = getchar()) >= '0') x = x * 10 + c - '0';
return -x;
}
int x = c - '0';
while ((c = getchar()) >= '0') x = x * 10 + c - '0';
return x;
}
const int N = 2e5 + 5, T = N * 3, D = 1e9 + 7;
int b[N];
long long s[T], s2[T];
int n, d;
void modify(int i, int w) {
i += d;
s[i] = w;
s2[i] = (long long)w * b[i - d] % D;
while (i >>= 1) {
s[i] = s[(i * 2)] + s[((i * 2) + 1)];
s2[i] = s2[(i * 2)] + s2[((i * 2) + 1)];
}
}
long long qiu(int i, int t) {
if (i == 0) return 0;
i += d;
long long a1 = s[i], a2 = s2[i];
while (i) {
if (i % 2) {
a1 += s[i - 1];
a2 += s2[i - 1];
}
i >>= 1;
}
return t == 1 ? a1 : a2;
}
int erfen(long long sum) {
int i = 1;
while (i <= d)
if (s[(i * 2)] >= sum)
i = (i * 2);
else {
sum -= s[(i * 2)];
i = ((i * 2) + 1);
}
return i - d;
}
int query(int l, int r) {
long long sum = qiu(r, 1) - qiu(l - 1, 1);
int m = erfen((sum + 1) / 2 + qiu(l - 1, 1));
return ((b[m] * ((qiu(m, 1) - qiu(l - 1, 1) - (qiu(r, 1) - qiu(m, 1))) % D) +
(qiu(r, 2) - qiu(m, 2) - (qiu(m, 2) - qiu(l - 1, 2)))) %
D +
D) %
D;
}
int main() {
n = read();
int m = read();
for (d = 1; d < n; d *= 2)
;
--d;
for (int i = 1; i <= n; ++i) b[i] = read() - i;
for (int i = 1; i <= n; ++i) modify(i, read());
while (m--) {
int x = read(), y = read();
if (x < 0)
modify(-x, y);
else
printf("%d\n", query(x, y));
}
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
For a given sequence of distinct non-negative integers (b_1, b_2, ..., b_k) we determine if it is good in the following way:
* Consider a graph on k nodes, with numbers from b_1 to b_k written on them.
* For every i from 1 to k: find such j (1 β€ j β€ k, jβ i), for which (b_i β b_j) is the smallest among all such j, where β denotes the operation of bitwise XOR (<https://en.wikipedia.org/wiki/Bitwise_operation#XOR>). Next, draw an undirected edge between vertices with numbers b_i and b_j in this graph.
* We say that the sequence is good if and only if the resulting graph forms a tree (is connected and doesn't have any simple cycles).
It is possible that for some numbers b_i and b_j, you will try to add the edge between them twice. Nevertheless, you will add this edge only once.
You can find an example below (the picture corresponding to the first test case).
Sequence (0, 1, 5, 2, 6) is not good as we cannot reach 1 from 5.
However, sequence (0, 1, 5, 2) is good.
<image>
You are given a sequence (a_1, a_2, ..., a_n) of distinct non-negative integers. You would like to remove some of the elements (possibly none) to make the remaining sequence good. What is the minimum possible number of removals required to achieve this goal?
It can be shown that for any sequence, we can remove some number of elements, leaving at least 2, so that the remaining sequence is good.
Input
The first line contains a single integer n (2 β€ n β€ 200,000) β length of the sequence.
The second line contains n distinct non-negative integers a_1, a_2, β¦, a_n (0 β€ a_i β€ 10^9) β the elements of the sequence.
Output
You should output exactly one integer β the minimum possible number of elements to remove in order to make the remaining sequence good.
Examples
Input
5
0 1 5 2 6
Output
1
Input
7
6 9 8 7 3 5 2
Output
2
Note
Note that numbers which you remove don't impact the procedure of telling whether the resulting sequence is good.
It is possible that for some numbers b_i and b_j, you will try to add the edge between them twice. Nevertheless, you will add this edge only once.
### Response
```cpp
#include <bits/stdc++.h>
#pragma GCC optimize(3)
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast,no-stack-protector")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC target("avx2,fma")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
using namespace std;
const int N = 400010, M = 33;
inline int read() {
int s = 0, w = 1;
register char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
s = (s << 3) + (s << 1) + (ch ^ 48), ch = getchar();
return s * w;
}
int n, a[N];
int ch[N * M][2], tot = 1;
inline void Insert(int x) {
int k = 1;
for (register int i = 30; ~i; i--) {
int p = (x >> i) & 1;
if (!ch[k][p]) ch[k][p] = ++tot;
k = ch[k][p];
}
}
int DFS(int x) {
if (!ch[x][0] && !ch[x][1]) return 1;
if (!ch[x][0]) return DFS(ch[x][1]);
if (!ch[x][1]) return DFS(ch[x][0]);
return max(DFS(ch[x][0]), DFS(ch[x][1])) + 1;
}
signed main() {
n = read();
for (register int i = 1; i <= n; i++) a[i] = read(), Insert(a[i]);
printf("%d\n", n - DFS(1));
return 0;
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
Iahub likes chess very much. He even invented a new chess piece named Coder. A Coder can move (and attack) one square horizontally or vertically. More precisely, if the Coder is located at position (x, y), he can move to (or attack) positions (x + 1, y), (xβ1, y), (x, y + 1) and (x, yβ1).
Iahub wants to know how many Coders can be placed on an n Γ n chessboard, so that no Coder attacks any other Coder.
Input
The first line contains an integer n (1 β€ n β€ 1000).
Output
On the first line print an integer, the maximum number of Coders that can be placed on the chessboard.
On each of the next n lines print n characters, describing the configuration of the Coders. For an empty cell print an '.', and for a Coder print a 'C'.
If there are multiple correct answers, you can print any.
Examples
Input
2
Output
2
C.
.C
### Response
```cpp
#include <bits/stdc++.h>
int main() {
std::ios::sync_with_stdio(0);
int n;
char m[1001][1001];
bool sw = 1;
for (int i = 1; i <= 1000; ++i) {
for (int j = 1; j <= 1000; ++j) {
if (sw) {
m[i][j] = 'C';
sw = 0;
} else {
m[i][j] = '.';
sw = 1;
}
}
sw = !sw;
}
std::cin >> n;
(n % 2 == 0 ? std::cout << n * n / 2 << "\n"
: std::cout << (n * n / 2) + 1 << "\n");
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
std::cout << m[i][j];
}
if (i < n) std::cout << "\n";
}
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
Malek has recently found a treasure map. While he was looking for a treasure he found a locked door. There was a string s written on the door consisting of characters '(', ')' and '#'. Below there was a manual on how to open the door. After spending a long time Malek managed to decode the manual and found out that the goal is to replace each '#' with one or more ')' characters so that the final string becomes beautiful.
Below there was also written that a string is called beautiful if for each i (1 β€ i β€ |s|) there are no more ')' characters than '(' characters among the first i characters of s and also the total number of '(' characters is equal to the total number of ')' characters.
Help Malek open the door by telling him for each '#' character how many ')' characters he must replace it with.
Input
The first line of the input contains a string s (1 β€ |s| β€ 105). Each character of this string is one of the characters '(', ')' or '#'. It is guaranteed that s contains at least one '#' character.
Output
If there is no way of replacing '#' characters which leads to a beautiful string print - 1. Otherwise for each character '#' print a separate line containing a positive integer, the number of ')' characters this character must be replaced with.
If there are several possible answers, you may output any of them.
Examples
Input
(((#)((#)
Output
1
2
Input
()((#((#(#()
Output
2
2
1
Input
#
Output
-1
Input
(#)
Output
-1
Note
|s| denotes the length of the string s.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e5 + 10;
long long int vis[N];
vector<vector<int> > v;
int dfs(int t) {
vis[t] = 1;
for (int i = 0; i < v[t].size(); i++) {
if (vis[v[t][t]] == 0) {
dfs(v[t][i]);
}
}
return 0;
}
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int lcm(int a, int b) { return a * (b / gcd(a, b)); }
vector<vector<int> > v2;
vector<int> v1;
int vis1[200005];
void printDivisors(int n) {
for (int i = 1; i <= sqrt(n); i++) {
if (n % i == 0) {
if (n / i == i)
v1.push_back(i);
else {
v1.push_back(i);
v1.push_back(n / i);
}
}
}
}
int main() {
string s;
cin >> s;
int flag = 0, cnt1 = 0, cnt2 = 0, ind = -1, v = 0;
for (int i = 0; i < (int)(s.size()); i++) {
if (s[i] == ')' or s[i] == '#') {
cnt1++;
} else
cnt2++;
if (cnt1 > cnt2) flag = 1;
}
for (int i = (int)(s.size()) - 1; i >= 0; i--) {
if (s[i] == '#') {
ind = i;
break;
}
if (s[i] == ')') v++;
}
cnt1 = 0;
int cnt3 = 0;
for (int i = 0; i < (int)(s.size()); i++) {
if (s[i] == ')')
cnt1++;
else if (s[i] == '#')
cnt3++;
}
if (flag)
printf("%d\n", -1);
else {
int h = cnt2 - (cnt3 + cnt1 - 1);
if (h <= 0)
printf("%d\n", -1);
else {
cnt1 = 0;
cnt2 = 0;
for (int i = 0; i < (int)(s.size()); i++) {
if (i == ind) {
for (int j = 0; j < h; j++) {
cnt1++;
}
} else if (s[i] == ')' or s[i] == '#') {
cnt1++;
} else
cnt2++;
if (cnt1 > cnt2) flag = 1;
}
if (flag)
printf("%d\n", -1);
else {
for (int i = 0; i < (int)(s.size()); i++) {
if (i == ind)
printf("%d\n", h);
else if (s[i] == '#')
printf("%d\n", 1);
}
}
}
}
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
Little X has a tree consisting of n nodes (they are numbered from 1 to n). Each edge of the tree has a positive length. Let's define the distance between two nodes v and u (we'll denote it d(v, u)) as the sum of the lengths of edges in the shortest path between v and u.
A permutation p is a sequence of n distinct integers p1, p2, ..., pn (1 β€ pi β€ n). Little X wants to find a permutation p such that sum <image> is maximal possible. If there are multiple optimal permutations, he wants to find the lexicographically smallest one. Help him with the task!
Input
The first line contains an integer n (1 β€ n β€ 105).
Each of the next n - 1 lines contains three space separated integers ui, vi, wi (1 β€ ui, vi β€ n; 1 β€ wi β€ 105), denoting an edge between nodes ui and vi with length equal to wi.
It is guaranteed that these edges form a tree.
Output
In the first line print the maximum possible value of the described sum. In the second line print n integers, representing the lexicographically smallest permutation.
Examples
Input
2
1 2 3
Output
6
2 1
Input
5
1 2 2
1 3 3
2 4 4
2 5 5
Output
32
2 1 4 5 3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxN = 1000 * 100 + 100;
vector<pair<int, int>> c[maxN];
int sz[maxN];
int dsz(int s, int p = -1) {
for (auto x : c[s])
if (x.first != p) sz[s] += dsz(x.first, s);
return ++sz[s];
}
int find_centroid(int s) {
int mn = dsz(s) / 2;
int p = -1;
bool found = false;
do {
found = false;
for (auto x : c[s])
if (x.first != p && sz[x.first] > mn) {
p = s, s = x.first, found = true;
break;
}
} while (found);
return s;
}
long long ans;
int col[maxN];
set<int> val[maxN];
void dfs(int s, int co, int p = -1, long long d = 0) {
col[s] = co;
val[co].insert(s);
ans += 2 * d;
for (auto x : c[s])
if (x.first != p) dfs(x.first, co, s, d + x.second);
}
set<pair<int, int>> curr, bad;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n - 1; i++) {
int u, v, w;
cin >> u >> v >> w;
u--;
v--;
c[u].push_back({v, w});
c[v].push_back({u, w});
}
int s = find_centroid(0);
col[s] = 0;
val[0].insert(s);
int cnt = 1;
for (auto x : c[s]) dfs(x.first, cnt++, s, x.second);
cout << ans << '\n';
memset(sz, 0, sizeof sz);
for (int i = 0; i < cnt; i++) {
curr.insert({*val[i].begin(), i});
if (i) bad.insert({2 * val[i].size(), i});
sz[i] = val[i].size();
}
int sum = n;
for (int i = 0; i < n; i++) {
auto it = curr.begin();
while ((col[i] && it->second == col[i]) && it != curr.end()) it++;
assert(it != curr.end());
if (bad.size()) {
auto p = *bad.rbegin();
if (col[i] != p.second) {
int x = sum;
if (it->second != p.second) x--;
if (p.first > x) it = curr.find({*val[p.second].begin(), p.second});
}
sum--;
bad.erase({sz[col[i]] + val[col[i]].size(), col[i]});
sz[col[i]]--;
if (col[i] != 0) bad.insert({sz[col[i]] + val[col[i]].size(), col[i]});
}
cout << it->first + 1 << " \n"[i == n - 1];
int x = it->second;
bad.erase({sz[x] + val[x].size(), x});
val[x].erase(it->first);
if (x != 0) bad.insert({sz[x] + val[x].size(), x});
curr.erase(it);
if (val[x].size()) curr.insert({*val[x].begin(), x});
}
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
Mishka received a gift of multicolored pencils for his birthday! Unfortunately he lives in a monochrome world, where everything is of the same color and only saturation differs. This pack can be represented as a sequence a1, a2, ..., an of n integer numbers β saturation of the color of each pencil. Now Mishka wants to put all the mess in the pack in order. He has an infinite number of empty boxes to do this. He would like to fill some boxes in such a way that:
* Each pencil belongs to exactly one box;
* Each non-empty box has at least k pencils in it;
* If pencils i and j belong to the same box, then |ai - aj| β€ d, where |x| means absolute value of x. Note that the opposite is optional, there can be pencils i and j such that |ai - aj| β€ d and they belong to different boxes.
Help Mishka to determine if it's possible to distribute all the pencils into boxes. Print "YES" if there exists such a distribution. Otherwise print "NO".
Input
The first line contains three integer numbers n, k and d (1 β€ k β€ n β€ 5Β·105, 0 β€ d β€ 109) β the number of pencils, minimal size of any non-empty box and maximal difference in saturation between any pair of pencils in the same box, respectively.
The second line contains n integer numbers a1, a2, ..., an (1 β€ ai β€ 109) β saturation of color of each pencil.
Output
Print "YES" if it's possible to distribute all the pencils into boxes and satisfy all the conditions. Otherwise print "NO".
Examples
Input
6 3 10
7 2 7 7 4 2
Output
YES
Input
6 2 3
4 5 3 13 4 10
Output
YES
Input
3 2 5
10 16 22
Output
NO
Note
In the first example it is possible to distribute pencils into 2 boxes with 3 pencils in each with any distribution. And you also can put all the pencils into the same box, difference of any pair in it won't exceed 10.
In the second example you can split pencils of saturations [4, 5, 3, 4] into 2 boxes of size 2 and put the remaining ones into another box.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long inf = 5e5 + 50;
const long long ninf = -1e9;
const long long mod = 1e9 + 7;
long long bit[inf];
long long n;
void update(long long i) {
while (i <= n + 5) {
bit[i] += 1;
i += (i & (-i));
}
}
long long query(long long i) {
long long sum = 0;
while (i > 0) {
sum += bit[i];
i -= (i & (-i));
}
return sum;
}
void solve() {
long long k, d;
cin >> n >> k >> d;
vector<long long> a(n);
for (long long i = 0; i < n; i++) cin >> a[i];
sort((a).begin(), (a).end());
vector<long long> dp(n + 5, 0);
dp[0] = 1;
update(1);
long long lft = 0;
for (long long i = 0; i < n; i++) {
while (lft < i && a[i] - a[lft] > d) {
lft++;
}
if (i - k + 2 >= lft)
dp[i + 1] = (query(i - k + 2) - query(lft)) >= 1 ? 1 : 0;
if (dp[i + 1]) {
update(i + 2);
}
}
if (dp[n]) {
cout << "YES";
} else
cout << "NO";
cout << "\n";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long T = 1;
while (T--) {
solve();
}
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
Little Vitaly loves different algorithms. Today he has invented a new algorithm just for you. Vitaly's algorithm works with string s, consisting of characters "x" and "y", and uses two following operations at runtime:
1. Find two consecutive characters in the string, such that the first of them equals "y", and the second one equals "x" and swap them. If there are several suitable pairs of characters, we choose the pair of characters that is located closer to the beginning of the string.
2. Find in the string two consecutive characters, such that the first of them equals "x" and the second one equals "y". Remove these characters from the string. If there are several suitable pairs of characters, we choose the pair of characters that is located closer to the beginning of the string.
The input for the new algorithm is string s, and the algorithm works as follows:
1. If you can apply at least one of the described operations to the string, go to step 2 of the algorithm. Otherwise, stop executing the algorithm and print the current string.
2. If you can apply operation 1, then apply it. Otherwise, apply operation 2. After you apply the operation, go to step 1 of the algorithm.
Now Vitaly wonders, what is going to be printed as the result of the algorithm's work, if the input receives string s.
Input
The first line contains a non-empty string s.
It is guaranteed that the string only consists of characters "x" and "y". It is guaranteed that the string consists of at most 106 characters. It is guaranteed that as the result of the algorithm's execution won't be an empty string.
Output
In the only line print the string that is printed as the result of the algorithm's work, if the input of the algorithm input receives string s.
Examples
Input
x
Output
x
Input
yxyxy
Output
y
Input
xxxxxy
Output
xxxx
Note
In the first test the algorithm will end after the first step of the algorithm, as it is impossible to apply any operation. Thus, the string won't change.
In the second test the transformation will be like this:
1. string "yxyxy" transforms into string "xyyxy";
2. string "xyyxy" transforms into string "xyxyy";
3. string "xyxyy" transforms into string "xxyyy";
4. string "xxyyy" transforms into string "xyy";
5. string "xyy" transforms into string "y".
As a result, we've got string "y".
In the third test case only one transformation will take place: string "xxxxxy" transforms into string "xxxx". Thus, the answer will be string "xxxx".
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
string s;
cin >> s;
int x = 0, y = 0;
for (int i = 0; i < s.size(); i++) s[i] == 'x' ? x++ : y++;
if (x > y)
for (int i = 0; i < x - y; i++) cout << "x";
else
for (int i = 0; i < y - x; i++) cout << "y";
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
The country Treeland consists of n cities, some pairs of them are connected with unidirectional roads. Overall there are n - 1 roads in the country. We know that if we don't take the direction of the roads into consideration, we can get from any city to any other one.
The council of the elders has recently decided to choose the capital of Treeland. Of course it should be a city of this country. The council is supposed to meet in the capital and regularly move from the capital to other cities (at this stage nobody is thinking about getting back to the capital from these cities). For that reason if city a is chosen a capital, then all roads must be oriented so that if we move along them, we can get from city a to any other city. For that some roads may have to be inversed.
Help the elders to choose the capital so that they have to inverse the minimum number of roads in the country.
Input
The first input line contains integer n (2 β€ n β€ 2Β·105) β the number of cities in Treeland. Next n - 1 lines contain the descriptions of the roads, one road per line. A road is described by a pair of integers si, ti (1 β€ si, ti β€ n; si β ti) β the numbers of cities, connected by that road. The i-th road is oriented from city si to city ti. You can consider cities in Treeland indexed from 1 to n.
Output
In the first line print the minimum number of roads to be inversed if the capital is chosen optimally. In the second line print all possible ways to choose the capital β a sequence of indexes of cities in the increasing order.
Examples
Input
3
2 1
2 3
Output
0
2
Input
4
1 4
2 4
3 4
Output
2
1 2 3
### Response
```cpp
#include <bits/stdc++.h>
const int N = 200000 + 5;
using namespace std;
bool is[N * 2];
struct E {
int to, next;
} e[N * 2];
int cnt, head[N];
int dp[N];
int ans[N];
void adde(int fr, int to) {
e[++cnt] = (E){to, head[fr]};
head[fr] = cnt;
}
void dfs(int o, int fa) {
for (int j = head[o]; j; j = e[j].next)
if (e[j].to != fa) {
dfs(e[j].to, o);
dp[o] += dp[e[j].to] + (is[j] ? 0 : 1);
}
}
void dfs2(int o, int fa) {
for (int j = head[o]; j; j = e[j].next)
if (e[j].to != fa) {
dp[e[j].to] = dp[o] + (is[j] ? 1 : -1);
ans[e[j].to] = dp[e[j].to];
dfs2(e[j].to, o);
}
}
int n, Ans = 1000000;
priority_queue<int> gr;
int q[N], l = 0;
int main() {
cin >> n;
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
adde(u, v);
is[cnt] = true;
adde(v, u);
}
dfs(1, 1);
ans[1] = dp[1];
dfs2(1, 1);
for (int i = 1; i <= n; i++) Ans = min(Ans, ans[i]);
cout << Ans << endl;
for (int i = 1; i <= n; i++)
if (Ans == ans[i]) gr.push(i);
while (!gr.empty()) {
int cur = gr.top();
gr.pop();
q[++l] = cur;
}
for (int i = l; i >= 1; i--) cout << q[i] << endl;
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
Given an array a, consisting of n integers, find:
$$$max_{1 β€ i < j β€ n} LCM(a_i,a_j),$$$
where LCM(x, y) is the smallest positive integer that is divisible by both x and y. For example, LCM(6, 8) = 24, LCM(4, 12) = 12, LCM(2, 3) = 6.
Input
The first line contains an integer n (2 β€ n β€ 10^5) β the number of elements in the array a.
The second line contains n integers a_1, a_2, ..., a_n (1 β€ a_i β€ 10^5) β the elements of the array a.
Output
Print one integer, the maximum value of the least common multiple of two elements in the array a.
Examples
Input
3
13 35 77
Output
1001
Input
6
1 2 4 8 16 32
Output
32
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, a[100001], cnt;
long long ans;
int gcd(int x, int y) { return y ? gcd(y, x % y) : x; }
long long lcm(int x, int y) {
long long res = 1ll * x * y;
return res / gcd(x, y);
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
n = unique(a + 1, a + n + 1) - a - 1;
for (int i = n; i >= 1; i--)
if (i >= n - 30 || (((a[i] ^ a[n]) & 1) && cnt < 30)) {
for (int j = n; j >= 1; j--) ans = max(ans, lcm(a[i], a[j]));
if (i < n - 30) cnt++;
}
cout << ans << '\n';
return 0;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
You are developing frog-shaped robots, and decided to race them against each other.
First, you placed N robots onto a number line. These robots are numbered 1 through N. The current coordinate of robot i is x_i. Here, all x_i are integers, and 0 < x_1 < x_2 < ... < x_N.
You will repeatedly perform the following operation:
* Select a robot on the number line. Let the coordinate of the robot be x. Select the destination coordinate, either x-1 or x-2, that is not occupied by another robot. The robot now jumps to the selected coordinate.
When the coordinate of a robot becomes 0 or less, the robot is considered finished and will be removed from the number line immediately. You will repeat the operation until all the robots finish the race.
Depending on your choice in the operation, the N robots can finish the race in different orders. In how many different orders can the N robots finish the race? Find the answer modulo 10^9+7.
Constraints
* 2 β€ N β€ 10^5
* x_i is an integer.
* 0 < x_1 < x_2 < ... < x_N β€ 10^9
Input
The input is given from Standard Input in the following format:
N
x_1 x_2 ... x_N
Output
Print the number of the different orders in which the N robots can finish the race, modulo 10^9+7.
Examples
Input
3
1 2 3
Output
4
Input
3
2 3 4
Output
6
Input
8
1 2 3 5 7 11 13 17
Output
10080
Input
13
4 6 8 9 10 12 14 15 16 18 20 21 22
Output
311014372
### Response
```cpp
#include <stdio.h>
#include <iostream>
#define FOR(i, n) for (int i = 1; i <= n; i++)
using namespace std;
#define N 100010
#define MOD 1000000007
int n, a[N];
int main() {
#ifdef QWERTIER
freopen("in.txt", "r", stdin);
#endif
scanf("%d", &n);
long long ans = 1, dec = 0;
FOR (i, n) {
scanf("%d", &a[i]);
if (a[i] >= 2*(i-dec)-1) {
ans = ans * (i-dec) % MOD;
} else {
ans = ans * (i - dec) % MOD;
//printf("%d %d\n", i, dec);
dec++;
}
}
cout << ans;
return 0;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
Dreamoon likes to play with sets, integers and <image>. <image> is defined as the largest positive integer that divides both a and b.
Let S be a set of exactly four distinct integers greater than 0. Define S to be of rank k if and only if for all pairs of distinct elements si, sj from S, <image>.
Given k and n, Dreamoon wants to make up n sets of rank k using integers from 1 to m such that no integer is used in two different sets (of course you can leave some integers without use). Calculate the minimum m that makes it possible and print one possible solution.
Input
The single line of the input contains two space separated integers n, k (1 β€ n β€ 10 000, 1 β€ k β€ 100).
Output
On the first line print a single integer β the minimal possible m.
On each of the next n lines print four space separated integers representing the i-th set.
Neither the order of the sets nor the order of integers within a set is important. If there are multiple possible solutions with minimal m, print any one of them.
Examples
Input
1 1
Output
5
1 2 3 5
Input
2 2
Output
22
2 4 6 22
14 18 10 16
Note
For the first example it's easy to see that set {1, 2, 3, 4} isn't a valid set of rank 1 since <image>.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m, cnt, snt, K;
long long oo = 1000000007;
void work() {
scanf("%d%d", &n, &m);
int a[6] = {0, 1, 2, 3, 5};
printf("%d\n", m * n * 6 - m);
for (int i = 1; i <= n; i++) {
printf("%d %d %d %d\n", a[1] * m, a[2] * m, a[3] * m, a[4] * m);
for (int j = 1; j <= 4; j++) a[j] += 6;
}
}
int main() {
work();
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
Celebrating the new year, many people post videos of falling dominoes; Here's a list of them: https://www.youtube.com/results?search_query=New+Years+Dominos
User ainta, who lives in a 2D world, is going to post a video as well.
There are n dominoes on a 2D Cartesian plane. i-th domino (1 β€ i β€ n) can be represented as a line segment which is parallel to the y-axis and whose length is li. The lower point of the domino is on the x-axis. Let's denote the x-coordinate of the i-th domino as pi. Dominoes are placed one after another, so p1 < p2 < ... < pn - 1 < pn holds.
User ainta wants to take a video of falling dominoes. To make dominoes fall, he can push a single domino to the right. Then, the domino will fall down drawing a circle-shaped orbit until the line segment totally overlaps with the x-axis.
<image>
Also, if the s-th domino touches the t-th domino while falling down, the t-th domino will also fall down towards the right, following the same procedure above. Domino s touches domino t if and only if the segment representing s and t intersects.
<image>
See the picture above. If he pushes the leftmost domino to the right, it falls down, touching dominoes (A), (B) and (C). As a result, dominoes (A), (B), (C) will also fall towards the right. However, domino (D) won't be affected by pushing the leftmost domino, but eventually it will fall because it is touched by domino (C) for the first time.
<image>
The picture above is an example of falling dominoes. Each red circle denotes a touch of two dominoes.
User ainta has q plans of posting the video. j-th of them starts with pushing the xj-th domino, and lasts until the yj-th domino falls. But sometimes, it could be impossible to achieve such plan, so he has to lengthen some dominoes. It costs one dollar to increase the length of a single domino by 1. User ainta wants to know, for each plan, the minimum cost needed to achieve it. Plans are processed independently, i. e. if domino's length is increased in some plan, it doesn't affect its length in other plans. Set of dominos that will fall except xj-th domino and yj-th domino doesn't matter, but the initial push should be on domino xj.
Input
The first line contains an integer n (2 β€ n β€ 2 Γ 105)β the number of dominoes.
Next n lines describe the dominoes. The i-th line (1 β€ i β€ n) contains two space-separated integers pi, li (1 β€ pi, li β€ 109)β the x-coordinate and the length of the i-th domino. It is guaranteed that p1 < p2 < ... < pn - 1 < pn.
The next line contains an integer q (1 β€ q β€ 2 Γ 105) β the number of plans.
Next q lines describe the plans. The j-th line (1 β€ j β€ q) contains two space-separated integers xj, yj (1 β€ xj < yj β€ n). It means the j-th plan is, to push the xj-th domino, and shoot a video until the yj-th domino falls.
Output
For each plan, print a line containing the minimum cost needed to achieve it. If no cost is needed, print 0.
Examples
Input
6
1 5
3 3
4 4
9 2
10 1
12 1
4
1 2
2 4
2 5
2 6
Output
0
1
1
2
Note
Consider the example. The dominoes are set like the picture below.
<image>
Let's take a look at the 4th plan. To make the 6th domino fall by pushing the 2nd domino, the length of the 3rd domino (whose x-coordinate is 4) should be increased by 1, and the 5th domino (whose x-coordinate is 9) should be increased by 1 (other option is to increase 4th domino instead of 5th also by 1). Then, the dominoes will fall like in the picture below. Each cross denotes a touch between two dominoes.
<image> <image> <image> <image> <image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <class T>
string toString(T n) {
ostringstream ost;
ost << n;
ost.flush();
return ost.str();
}
int toInt(string s) {
int r = 0;
istringstream sin(s);
sin >> r;
return r;
}
long long toLInt(string s) {
long long r = 0;
istringstream sin(s);
sin >> r;
return r;
}
vector<string> parse(string temp) {
vector<string> ans;
ans.clear();
string s;
istringstream iss(temp);
while (iss >> s) ans.push_back(s);
return ans;
}
template <typename T>
inline unsigned long long dist(T A, T B) {
unsigned long long res =
(A.x - B.x) * (A.x - B.x) + (A.y - B.y) * (A.y - B.y);
return res;
}
template <typename T>
inline double cosAngle(T a, T b, T c) {
double res = a * a + b * b - c * c;
res = res / (2 * a * b);
res = acos(res);
return res;
}
template <class T>
inline T gcd(T a, T b) {
if (a < 0) return gcd(-a, b);
if (b < 0) return gcd(a, -b);
return (b == 0) ? a : gcd(b, a % b);
}
template <class T>
inline T lcm(T a, T b) {
if (a < 0) return lcm(-a, b);
if (b < 0) return lcm(a, -b);
return a * (b / gcd(a, b));
}
template <class T>
inline T power(T b, T p) {
if (p < 0) return -1;
if (b <= 0) return -2;
if (!p) return 1;
return b * power(b, p - 1);
}
template <class T>
int bit_count(T no) {
int cnt = 0;
while (no) {
no = no >> 1;
cnt++;
}
return cnt;
}
void seive(int lm, int arr[]) {
for (int i = 2; i * i <= lm; i++)
if (arr[i] == 0)
for (int j = 1; j * i <= lm; j++) arr[i * j] = 1;
}
template <class T>
void showBit(T N) {
T zero = 0, one = 1;
if (N == zero) return;
showBit(N >> 1);
printf("%d", N & one);
}
long long binToDec(string s) {
int ln = s.length();
long long sum = 0;
for (int i = ln - 1, k = 0; i >= 0; i--, k++)
sum = sum + (s[i] - '0') * (1 << k);
return sum;
}
string rev(string s) {
string rs = "";
int l = s.length();
for (int i = l - 1; i >= 0; i--) rs = rs + s[i];
return rs;
}
template <typename T>
string decToBin(T n, int dg) {
string s = "";
int td = 0;
while (n) {
int cb = n & 1;
s = s + (char)(cb + '0');
n = n >> 1;
td++;
}
string as = "";
while (td != dg) {
as = as + "0";
td++;
}
as = as + rev(s);
return as;
}
void combination(long long com[][1005]) {
com[0][0] = 1;
int sz = 1000;
for (int i = 1; i <= sz; i++) {
com[i][0] = 1;
for (int j = 1; j <= i; j++) {
com[i][j] = com[i - 1][j] + com[i - 1][j - 1];
com[i][j] = com[i][j] % 1000000007;
}
}
}
template <class T>
T bigmod(T bs, T p, T mod) {
if (mod <= 0) {
printf("Exception");
return 0;
}
T ans = 1;
T k = bs;
while (p) {
if (p & 1) {
ans = ans * k;
ans %= mod;
}
k *= k;
k %= mod;
p = p >> 1;
}
return ans;
}
void pattern_match(char pat[], const int len, int pi[]) {
pi[0] = 0;
for (int i = 1; i < len; i++) {
int ch = pi[i - 1];
while (pat[ch] != pat[i]) {
if (ch == 0) {
ch = -1;
break;
}
ch = pi[ch - 1];
}
pi[i] = ch + 1;
}
}
void pattern_match(char pat[], int pi[], char tar[], const int len1, int gi[]) {
if (pat[0] == tar[0]) gi[0] = 1;
for (int i = 1; i < len1; i++) {
int st = gi[i - 1];
while (pat[st] != tar[i]) {
if (st == 0) {
st = -1;
break;
}
st = pi[st - 1];
}
if (st == -1)
gi[i] = 0;
else
gi[i] = st + 1;
}
}
struct myArray {
int mat[10][10];
};
myArray matrix_mul(myArray mat1, myArray mat2, const int sz) {
int tmp[sz][sz];
memset((tmp), 0, sizeof((tmp)));
for (int r = 0; r < sz; r++)
for (int c = 0; c < sz; c++)
for (int cr = 0; cr < sz; cr++)
tmp[r][c] += mat1.mat[r][cr] * mat2.mat[cr][c];
myArray res;
for (int r = 0; r < sz; r++)
for (int c = 0; c < sz; c++) res.mat[r][c] = tmp[r][c];
return res;
}
myArray unit_matrix(const int sz) {
myArray ma;
memset((ma.mat), 0, sizeof((ma.mat)));
for (int i = 0; i < sz; i++) ma.mat[i][i] = 1;
return ma;
}
myArray matrix_expo(int p, myArray mat, const int sz) {
if (p == 0) {
return unit_matrix(sz);
}
if (p & 1) return matrix_mul(mat, matrix_expo(p - 1, mat, sz), sz);
myArray tmp = matrix_expo(p >> 1, mat, sz);
return matrix_mul(tmp, tmp, sz);
}
map<string, int> msi;
void cal_state(string s, int tran[][30]) {
int ln = s.length();
string s1 = s;
for (int i = 0; i < ln; i++) {
msi[s1] = ln - i;
s1 = s1.substr(0, ln - i - 1);
}
s1 = "";
for (int i = 0; i < ln; i++) {
string ts = s1;
for (int j = 0; j < 26; j++) {
s1 = ts + (char)('a' + j);
int tln = i + 1;
while (msi[s1] == 0) {
s1 = s1.substr(1);
tln--;
if (tln == 0) break;
}
if (tln == 0) s1 = "";
tran[i][j] = msi[s1];
}
s1 = s.substr(0, i + 1);
}
}
double distance(double x1, double y1, double x2, double y2) {
return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}
int X[] = {0, 0, 1, -1};
int Y[] = {1, -1, 0, 0};
const int dx[8] = {-1, 1, -2, 2, -1, 1, -2, 2};
const int dy[8] = {2, 2, -1, -1, -2, -2, 1, 1};
int n, m;
int posTree[1 << 19];
int rigt[1 << 19];
int p[2 * 100005], l[2 * 100005];
int dp[2 * 100005][20];
int dp1[2 * 100005][20];
int cost[2 * 100005][20];
void insertPos(int cs, int s, int e, int i) {
if (s == e) {
posTree[cs] = i;
return;
}
int m = (s + e) / 2;
if (i <= m)
insertPos(2 * cs, s, m, i);
else
insertPos(2 * cs + 1, m + 1, e, i);
posTree[cs] = max(posTree[2 * cs], posTree[2 * cs + 1]);
}
void insertRight(int cs, int s, int e, int i) {
if (s == e) {
rigt[cs] = i;
return;
}
int m = (s + e) / 2;
if (i <= m)
insertRight(2 * cs, s, m, i);
else
insertRight(2 * cs + 1, m + 1, e, i);
rigt[cs] = rigt[2 * cs + 1];
if (p[rigt[2 * cs]] + l[rigt[2 * cs]] >
p[rigt[2 * cs + 1]] + l[rigt[2 * cs + 1]])
rigt[cs] = rigt[2 * cs];
}
int findPos(int cs, int s, int e, int i) {
if (s == e) return posTree[cs];
int m = (s + e) / 2;
int lm = posTree[2 * cs];
if (p[lm + 1] > i) return findPos(2 * cs, s, m, i);
return findPos(2 * cs + 1, m + 1, e, i);
}
int findRange(int cs, int a, int b, int s, int e) {
if (s == a && e == b) return rigt[cs];
int m = (s + e) / 2;
int li = 0, ri = 0;
if (a <= m) li = findRange(2 * cs, a, min(b, m), s, m);
if (b > m) ri = findRange(2 * cs + 1, max(a, m + 1), b, m + 1, e);
if (p[li] + l[li] > p[ri] + l[ri]) return li;
return ri;
}
int cal(int a, int b, int pw) {
if (pw < 0) return 0;
if (dp[a][pw] == b) return cost[a][pw];
if (dp[a][pw] > b) return cal(a, b, pw - 1);
return cost[a][pw] + p[dp[a][pw] + 1] - dp1[a][pw] +
cal(dp[a][pw] + 1, b, pw);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &p[i], &l[i]);
insertPos(1, 1, n, i);
insertRight(1, 1, n, i);
}
for (int i = n; i >= 1; i--) {
int a = i;
int b = findPos(1, 1, n, p[i] + l[i]);
dp[i][0] = b;
dp1[i][0] = p[i] + l[i];
int ri = findRange(1, a, b, 1, n);
dp[i][0] = dp[ri][0];
dp1[i][0] = dp1[ri][0];
}
for (int i = 1; i <= 18; i++)
for (int j = 1; j <= n; j++) {
if (dp[j][i - 1] >= n) {
dp[j][i] = n + 1;
continue;
}
dp[j][i] = dp[dp[j][i - 1] + 1][i - 1];
dp1[j][i] = dp1[dp[j][i - 1] + 1][i - 1];
cost[j][i] = cost[j][i - 1] + cost[dp[j][i - 1] + 1][i - 1] +
p[dp[j][i - 1] + 1] - dp1[j][i - 1];
}
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
int a, b;
scanf("%d%d", &a, &b);
printf("%d", cal(a, b, 18));
printf("\n");
}
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
One day n students come to the stadium. They want to play football, and for that they need to split into teams, the teams must have an equal number of people.
We know that this group of people has archenemies. Each student has at most two archenemies. Besides, if student A is an archenemy to student B, then student B is an archenemy to student A.
The students want to split so as no two archenemies were in one team. If splitting in the required manner is impossible, some students will have to sit on the bench.
Determine the minimum number of students you will have to send to the bench in order to form the two teams in the described manner and begin the game at last.
Input
The first line contains two integers n and m (2 β€ n β€ 100, 1 β€ m β€ 100) β the number of students and the number of pairs of archenemies correspondingly.
Next m lines describe enmity between students. Each enmity is described as two numbers ai and bi (1 β€ ai, bi β€ n, ai β bi) β the indexes of the students who are enemies to each other. Each enmity occurs in the list exactly once. It is guaranteed that each student has no more than two archenemies.
You can consider the students indexed in some manner with distinct integers from 1 to n.
Output
Print a single integer β the minimum number of students you will have to send to the bench in order to start the game.
Examples
Input
5 4
1 2
2 4
5 3
1 4
Output
1
Input
6 2
1 4
3 4
Output
0
Input
6 6
1 2
2 3
3 1
4 5
5 6
6 4
Output
2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m;
int parent[105];
int num[105];
int Rank[105];
void init(int n) {
for (int i = 0; i < n; i++) {
parent[i] = i;
num[i] = 1;
Rank[i] = 0;
}
}
int findroot(int x) {
if (parent[x] != x) {
return parent[x] = findroot(parent[x]);
}
return parent[x];
}
int main() {
int x, y, ans = 0;
cin >> n >> m;
init(n);
for (int i = 0; i < m; ++i) {
cin >> x >> y;
int xIndex = findroot(x);
int yIndex = findroot(y);
if (xIndex == yIndex && num[xIndex] % 2) ans++;
parent[yIndex] = xIndex;
num[xIndex] += num[yIndex];
}
if ((n - ans) % 2) ans++;
cout << ans << endl;
return 0;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
Nauuo is a girl who loves playing chess.
One day she invented a game by herself which needs n chess pieces to play on a mΓ m chessboard. The rows and columns are numbered from 1 to m. We denote a cell on the intersection of the r-th row and c-th column as (r,c).
The game's goal is to place n chess pieces numbered from 1 to n on the chessboard, the i-th piece lies on (r_i,\,c_i), while the following rule is satisfied: for all pairs of pieces i and j, |r_i-r_j|+|c_i-c_j|β₯|i-j|. Here |x| means the absolute value of x.
However, Nauuo discovered that sometimes she couldn't find a solution because the chessboard was too small.
She wants to find the smallest chessboard on which she can put n pieces according to the rules.
She also wonders how to place the pieces on such a chessboard. Can you help her?
Input
The only line contains a single integer n (1β€ nβ€ 1000) β the number of chess pieces for the game.
Output
The first line contains a single integer β the minimum value of m, where m is the length of sides of the suitable chessboard.
The i-th of the next n lines contains two integers r_i and c_i (1β€ r_i,c_iβ€ m) β the coordinates of the i-th chess piece.
If there are multiple answers, print any.
Examples
Input
2
Output
2
1 1
1 2
Input
4
Output
3
1 1
1 3
3 1
3 3
Note
In the first example, you can't place the two pieces on a 1Γ1 chessboard without breaking the rule. But you can place two pieces on a 2Γ2 chessboard like this:
<image>
In the second example, you can't place four pieces on a 2Γ2 chessboard without breaking the rule. For example, if you place the pieces like this:
<image>
then |r_1-r_3|+|c_1-c_3|=|1-2|+|1-1|=1, |1-3|=2, 1<2; and |r_1-r_4|+|c_1-c_4|=|1-2|+|1-2|=2, |1-4|=3, 2<3. It doesn't satisfy the rule.
However, on a 3Γ3 chessboard, you can place four pieces like this:
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pll = pair<ll, ll>;
using dd = long double;
namespace {
static bool constexpr dbg = 0;
ll constexpr N = -999;
ll n;
void solve() {
cin >> n;
ll const k = n / 2 + 1;
cout << k << '\n';
int x = 1, y = 1;
for (ll _ = 0, ii_ = (n); _ < ii_; ++_) {
cout << x << ' ' << y << '\n';
if (y < k)
++y;
else
++x;
}
}
} // namespace
int main() {
if (!dbg) {
std::ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
cout << fixed << setprecision(20);
solve();
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
Malek is a rich man. He also is very generous. That's why he decided to split his money between poor people. A charity institute knows n poor people numbered from 1 to n. The institute gave Malek q recommendations. A recommendation is a segment of people like [l, r] which means the institute recommended that Malek gives one dollar to every person whose number is in this segment.
However this charity has very odd rules about the recommendations. Because of those rules the recommendations are given in such a way that for every two recommendation [a, b] and [c, d] one of the following conditions holds:
* The two segments are completely disjoint. More formally either a β€ b < c β€ d or c β€ d < a β€ b
* One of the two segments are inside another. More formally either a β€ c β€ d β€ b or c β€ a β€ b β€ d.
The goodness of a charity is the value of maximum money a person has after Malek finishes giving his money. The institute knows for each recommendation what is the probability that Malek will accept it. They want to know the expected value of goodness of this charity. So they asked you for help.
You have been given the list of recommendations and for each recommendation the probability of it being accepted by Malek. You have also been given how much money each person initially has. You must find the expected value of goodness.
Input
In the first line two space-separated integers n, q (1 β€ n β€ 105, 1 β€ q β€ 5000) are given.
In the second line n space-separated integers a1, a2, ..., an (0 β€ ai β€ 109) are given meaning that person number i initially has ai dollars.
Each of the next q lines contains three space-separated numbers li, ri, pi (1 β€ li β€ ri β€ n, 0 β€ p β€ 1) where li and ri are two integers describing the segment of recommendation and pi is a real number given with exactly three digits after decimal point which is equal to probability of Malek accepting this recommendation.
Note that a segment may appear several times in recommendations.
Output
Output the sought value. Your answer will be considered correct if its absolute or relative error is less than 10 - 6.
Examples
Input
5 2
1 7 2 4 3
1 3 0.500
2 2 0.500
Output
8.000000000
Input
5 2
281 280 279 278 282
1 4 1.000
1 4 0.000
Output
282.000000000
Input
3 5
1 2 3
1 3 0.500
2 2 0.250
1 2 0.800
1 1 0.120
2 2 0.900
Output
4.465000000
### Response
```cpp
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma comment(linker, "/STACK:100000000")
const double pi = acos(-1);
const int MOD = 1e9 + 7;
const int INF = 1e9 + 7;
const int MAXN = 5e3 + 5;
const double eps = 1e-9;
using namespace std;
bool vis[MAXN];
int a[MAXN * 20], L[MAXN], R[MAXN], mx[MAXN];
double dp[MAXN][MAXN], P[MAXN], tmp2[MAXN];
set<int> ind;
int main() {
int n, q;
scanf("%d", &(n)), scanf("%d", &(q));
for (int i = 0; i < n; i++) ind.insert(i);
for (int i = 0; i < (n); i++) scanf("%d", &(a[i]));
for (int i = 0; i < q; i++) {
scanf("%d %d %lf", L + i, R + i, P + i);
L[i]--, R[i]--;
for (int j = 0; j < i; j++)
if (R[j] - L[j] > R[i] - L[i])
swap(L[i], L[j]), swap(R[i], R[j]), swap(P[i], P[j]);
}
L[q] = 0, R[q] = n - 1, P[q] = 0, q++;
for (int i = 0; i < q; i++) {
vector<int> tmp;
for (int j = 0; j < i; j++)
if (L[i] <= L[j] && R[j] <= R[i] && !vis[j]) {
vis[j] = 1;
tmp.push_back(j);
mx[i] = max(mx[i], mx[j]);
}
while (1) {
set<int>::iterator it = ind.lower_bound(L[i]);
if (it != ind.end() && *it <= R[i])
mx[i] = max(mx[i], a[*it]), ind.erase(it);
else
break;
}
for (int j = 0; j <= q; j++) tmp2[j] = 1;
for (int x = 0; x < tmp.size(); x++) {
int j = tmp[x];
for (int k = 0; k <= q; k++)
if (mx[i] + k - mx[j] <= q) tmp2[k] *= dp[j][mx[i] + k - mx[j]];
}
for (int j = q; j > 0; j--) tmp2[j] -= tmp2[j - 1];
dp[i][0] = (1 - P[i]) * tmp2[0];
for (int j = 1; j <= q; j++)
dp[i][j] = dp[i][j - 1] + P[i] * tmp2[j - 1] + (1 - P[i]) * tmp2[j];
}
double ans = dp[q - 1][0] * mx[q - 1];
for (int i = 1; i <= q; i++)
ans += (dp[q - 1][i] - dp[q - 1][i - 1]) * (mx[q - 1] + i);
printf("%.15f\n", ans);
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
"Hey, it's homework time" β thought Polycarpus and of course he started with his favourite subject, IT. Polycarpus managed to solve all tasks but for the last one in 20 minutes. However, as he failed to solve the last task after some considerable time, the boy asked you to help him.
The sequence of n integers is called a permutation if it contains all integers from 1 to n exactly once.
You are given an arbitrary sequence a1, a2, ..., an containing n integers. Each integer is not less than 1 and not greater than 5000. Determine what minimum number of elements Polycarpus needs to change to get a permutation (he should not delete or add numbers). In a single change he can modify any single sequence element (i. e. replace it with another integer).
Input
The first line of the input data contains an integer n (1 β€ n β€ 5000) which represents how many numbers are in the sequence. The second line contains a sequence of integers ai (1 β€ ai β€ 5000, 1 β€ i β€ n).
Output
Print the only number β the minimum number of changes needed to get the permutation.
Examples
Input
3
3 1 2
Output
0
Input
2
2 2
Output
1
Input
5
5 3 3 3 1
Output
2
Note
The first sample contains the permutation, which is why no replacements are required.
In the second sample it is enough to replace the first element with the number 1 and that will make the sequence the needed permutation.
In the third sample we can replace the second element with number 4 and the fourth element with number 2.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char *argv[]) {
int n, t, changes = 0, remainder = 0;
cin >> n;
vector<bool> seed(n);
remainder = n;
for (int i = 0; i < n; ++i) {
cin >> t;
if (t > n || seed[t - 1])
changes++;
else {
remainder--;
seed[t - 1] = true;
}
}
cout << min(changes, remainder) << endl;
return EXIT_SUCCESS;
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
Snuke is having another barbeque party.
This time, he will make one serving of Skewer Meal.
He has a stock of N Skewer Meal Packs. The i-th Skewer Meal Pack contains one skewer, A_i pieces of beef and B_i pieces of green pepper. All skewers in these packs are different and distinguishable, while all pieces of beef and all pieces of green pepper are, respectively, indistinguishable.
To make a Skewer Meal, he chooses two of his Skewer Meal Packs, and takes out all of the contents from the chosen packs, that is, two skewers and some pieces of beef or green pepper. (Remaining Skewer Meal Packs will not be used.) Then, all those pieces of food are threaded onto both skewers, one by one, in any order.
(See the image in the Sample section for better understanding.)
In how many different ways can he make a Skewer Meal? Two ways of making a Skewer Meal is different if and only if the sets of the used skewers are different, or the orders of the pieces of food are different. Since this number can be extremely large, find it modulo 10^9+7.
Constraints
* 2β¦Nβ¦200,000
* 1β¦A_iβ¦2000, 1β¦B_iβ¦2000
Input
The input is given from Standard Input in the following format:
N
A_1 B_1
A_2 B_2
:
A_N B_N
Output
Print the number of the different ways Snuke can make a serving of Skewer Meal, modulo 10^9+7.
Example
Input
3
1 1
1 1
2 1
Output
26
### Response
```cpp
#include<cstdio>
#include<algorithm>
#include<cstring>
#define MN 4005
using namespace std;
typedef long long ll;
int n,a[200005],b[200005];
const int mod=1e9+7;
ll inv[MN<<1],fac[MN<<1],ans,f[MN][MN];
ll C(int x,int y){return fac[x]*inv[x-y]%mod*inv[y]%mod;}
int main(){
fac[0]=fac[1]=inv[0]=inv[1]=1;
for(int i=2;i<=8002;i++)fac[i]=fac[i-1]*i%mod,inv[i]=1ll*(mod-mod/i)*inv[mod%i]%mod;
for(int i=2;i<=8002;i++)inv[i]=inv[i-1]*inv[i]%mod;scanf("%d",&n);
for(int i=1;i<=n;i++)scanf("%d%d",&a[i],&b[i]),f[2001-a[i]][2001-b[i]]++;
for(int i=1;i<=4002;i++)for(int j=1;j<=4002;j++)f[i][j]=(f[i][j]+f[i-1][j]+f[i][j-1])%mod;
for(int i=1;i<=n;i++)ans=((ans+f[2001+a[i]][2001+b[i]]-C((a[i]+b[i])*2,b[i]*2)%mod)%mod+mod)%mod;
printf("%lld\n",ans*inv[2]%mod);
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
Two players play a game.
Initially there are n integers a_1, a_2, β¦, a_n written on the board. Each turn a player selects one number and erases it from the board. This continues until there is only one number left on the board, i. e. n - 1 turns are made. The first player makes the first move, then players alternate turns.
The first player wants to minimize the last number that would be left on the board, while the second player wants to maximize it.
You want to know what number will be left on the board after n - 1 turns if both players make optimal moves.
Input
The first line contains one integer n (1 β€ n β€ 1000) β the number of numbers on the board.
The second line contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^6).
Output
Print one number that will be left on the board.
Examples
Input
3
2 1 3
Output
2
Input
3
2 2 2
Output
2
Note
In the first sample, the first player erases 3 and the second erases 1. 2 is left on the board.
In the second sample, 2 is left on the board regardless of the actions of the players.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int i, j, k, sum = 0, ans, c, d, t = 0;
long long int n, m;
vector<long long int> v, v1, v2;
cin >> n;
c = n / 2;
long long int a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
if (n % 2 == 0) {
cout << a[c - 1] << endl;
} else
cout << a[c] << endl;
return 0;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
We have a board with an H \times W grid. Each square in the grid is painted in black or white. The square at the i-th row from the top and j-th column from the left is black if the j-th character in S_i is `#`, and white if that character is `.`.
Snuke can perform the following operation on the grid any number of times:
* Select a row or column in the grid, and invert the color of all the squares in that row or column (that is, black squares become white and vice versa).
Then, Snuke draws a rectangle along grid lines. Here, all the squares contained in the rectangle must be painted in black.
Find the maximum possible area of Snuke's rectangle when the operation is performed optimally.
Constraints
* 2 \leq H \leq 2000
* 2 \leq W \leq 2000
* |S_i| = W
* S_i consists of `#` and `.`.
Input
Input is given from Standard Input in the following format:
H W
S_1
S_2
:
S_H
Output
Print the maximum possible area of Snuke's rectangle.
Examples
Input
3 3
..#
##.
.#.
Output
6
Input
3 3
..#
.
.#.
Output
6
Input
4 4
....
....
....
....
Output
16
Input
10 8
...#.#
...#.#
..###.#.
.##.#.#
.#..#.#.
..##.#.#
.#.#..
...#.#..
.#.##
..###
Output
27
### Response
```cpp
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
bool a[2005][2005];
int down[2005][2005],l[2005],r[2005];
char str[2005];
int st[2005];
int main() {
int n,m;
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++) {
scanf("%s",str+1);
for(int j=1;j<=m;j++) a[i][j]=(str[j]=='#');
}
for(int i=n;i>1;i--)
for(int j=m;j>1;j--) a[i][j]=!(a[i-1][j-1]^a[i-1][j]^a[i][j-1]^a[i][j]);
for(int i=n;i>1;i--)
for(int j=m;j>1;j--) down[i][j]=(a[i][j])?down[i+1][j]+1:0;
int ans=max(n,m);
for(int i=2;i<=n;i++) {
int top=0;
st[top]=1;
for(int j=2;j<=m;j++) {
while (top&&down[i][j]<=down[i][st[top]]) top--;
l[j]=st[top]+1;
st[++top]=j;
}
top=0;
st[top]=m+1;
for(int j=m;j>1;j--) {
while (top&&down[i][j]<=down[i][st[top]]) top--;
r[j]=st[top]-1;
st[++top]=j;
}
for(int j=2;j<=m;j++) ans=max(ans,(r[j]-l[j]+2)*(down[i][j]+1));
}
printf("%d\n",ans);
return 0;
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
Chokudai made a rectangular cake for contestants in DDCC 2020 Finals.
The cake has H - 1 horizontal notches and W - 1 vertical notches, which divide the cake into H \times W equal sections. K of these sections has a strawberry on top of each of them.
The positions of the strawberries are given to you as H \times W characters s_{i, j} (1 \leq i \leq H, 1 \leq j \leq W). If s_{i, j} is `#`, the section at the i-th row from the top and the j-th column from the left contains a strawberry; if s_{i, j} is `.`, the section does not contain one. There are exactly K occurrences of `#`s.
Takahashi wants to cut this cake into K pieces and serve them to the contestants. Each of these pieces must satisfy the following conditions:
* Has a rectangular shape.
* Contains exactly one strawberry.
One possible way to cut the cake is shown below:
Find one way to cut the cake and satisfy the condition. We can show that this is always possible, regardless of the number and positions of the strawberries.
Constraints
* 1 \leq H \leq 300
* 1 \leq W \leq 300
* 1 \leq K \leq H \times W
* s_{i, j} is `#` or `.`.
* There are exactly K occurrences of `#` in s.
Input
Input is given from Standard Input in the following format:
H W K
s_{1, 1} s_{1, 2} \cdots s_{1, W}
s_{2, 1} s_{2, 2} \cdots s_{2, W}
:
s_{H, 1} s_{H, 2} \cdots s_{H, W}
Output
Assign the numbers 1, 2, 3, \dots, K to the K pieces obtained after the cut, in any order. Then, let a_{i, j} be the number representing the piece containing the section at the i-th row from the top and the j-th column from the left of the cake. Output should be in the following format:
a_{1, 1} \ a_{1, 2} \ \cdots \ a_{1, W}
a_{2, 1} \ a_{2, 2} \ \cdots \ a_{2, W}
:
a_{H, 1} \ a_{H, 2} \ \cdots \ a_{H, W}
If multiple solutions exist, any of them will be accepted.
Examples
Input
3 3 5
#.#
.#.
#.#
Output
1 2 2
1 3 4
5 5 4
Input
3 3 5
.#
.#.
.#
Output
1 2 2
1 3 4
5 5 4
Input
3 7 7
...#.#
..#...#
.#..#..
Output
1 1 2 2 3 4 4
6 6 2 2 3 5 5
6 6 7 7 7 7 7
Input
13 21 106
.....................
.####.####.####.####.
..#.#..#.#.#....#....
..#.#..#.#.#....#....
..#.#..#.#.#....#....
.####.####.####.####.
.....................
.####.####.####.####.
....#.#..#....#.#..#.
.####.#..#.####.#..#.
.#....#..#.#....#..#.
.####.####.####.####.
.....................
Output
12 12 23 34 45 45 60 71 82 93 93 2 13 24 35 35 17 28 39 50 50
12 12 23 34 45 45 60 71 82 93 93 2 13 24 35 35 17 28 39 50 50
12 12 56 89 89 89 60 104 82 31 31 46 13 24 35 35 61 61 39 50 50
12 12 67 67 100 100 60 9 9 42 42 57 13 24 6 72 72 72 72 72 72
12 12 78 5 5 5 20 20 20 53 68 68 90 24 6 83 83 83 83 83 83
16 16 27 38 49 49 64 75 86 97 79 79 90 101 6 94 94 105 10 21 21
16 16 27 38 49 49 64 75 86 97 79 79 90 101 6 94 94 105 10 21 21
32 32 43 54 65 65 80 11 106 95 22 22 33 44 55 55 70 1 96 85 85
32 32 43 54 76 76 91 11 106 84 84 4 99 66 66 66 81 1 96 74 74
14 14 3 98 87 87 102 11 73 73 73 4 99 88 77 77 92 92 63 63 63
25 25 3 98 87 87 7 29 62 62 62 15 99 88 77 77 103 19 30 52 52
36 36 47 58 69 69 18 29 40 51 51 26 37 48 59 59 8 19 30 41 41
36 36 47 58 69 69 18 29 40 51 51 26 37 48 59 59 8 19 30 41 41
### Response
```cpp
#include <bits/stdc++.h>
#define ff first
#define ss second
#define mp make_pair
using namespace std;
typedef long long ll;
char mat[305][305];
int ans[305][305];
int main() {
int n,m,k;
scanf("%d%d%d", &n, &m, &k);
for(int i = 0; i < n; i++){
scanf(" %s", mat[i]);
}
int cur = 0;
for(int j = 0; j < m; j++) {
bool found = false;
for(int i = 0; i < n; i++) {
if(mat[i][j] == '#') {
found = true;
cur++;
break;
}
}
if(!found) continue;
bool first = true;
for(int i = 0; i < n; i++) {
if(mat[i][j] == '.') ans[i][j] = cur;
else {
if(first) ans[i][j] = cur;
else ans[i][j] = ++cur;
first = false;
}
}
}
for(int j = 1; j < m; j++) {
for(int i = 0; i < n; i++)
if(ans[i][j] == 0) ans[i][j] = ans[i][j-1];
}
for(int j = m-2; j >= 0; j--) {
for(int i = 0; i < n; i++)
if(ans[i][j] == 0) ans[i][j] = ans[i][j+1];
}
for(int i = 0; i < n; i++) {
for(int j = 0; j < m; j++)
printf("%d%c",ans[i][j], " \n"[j==m-1]);
}
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
Let us define the FizzBuzz sequence a_1,a_2,... as follows:
* If both 3 and 5 divides i, a_i=\mbox{FizzBuzz}.
* If the above does not hold but 3 divides i, a_i=\mbox{Fizz}.
* If none of the above holds but 5 divides i, a_i=\mbox{Buzz}.
* If none of the above holds, a_i=i.
Find the sum of all numbers among the first N terms of the FizzBuzz sequence.
Constraints
* 1 \leq N \leq 10^6
Input
Input is given from Standard Input in the following format:
N
Output
Print the sum of all numbers among the first N terms of the FizzBuzz sequence.
Examples
Input
15
Output
60
Input
1000000
Output
266666333332
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
using ll=long long;
ll s;
int main(){
int N;
cin>>N;
for(int i=0;i<=N;i++){
if(i%3&&i%5)s+=i;
}
cout<<s<<endl;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
There are n cups of different sizes and three trays (bon festivals) A, B, and C, and these cups are placed on top of each of the three trays in a pile. However, in any tray, the smallest cup in the tray is on the bottom, the second smallest cup is on top, and the third smallest cup is on top, in ascending order. .. For example, the right side of the figure below shows a state in which n = 5 cups are placed on trays A, B, and C, respectively, with 2, 0, and 3 stacked.
<image>
In this way, given the initial state of the cups, how many moves should be made to move all the cups to either the A or C tray, observing the following rules 1-3. I want to find it.
(Rule 1) Only one cup can be moved at a time. It is the top cup (that is, the largest cup) of the cups in the tray.
(Rule 2) Do not stack small cups on top of large ones.
(Rule 3) Only tray A to B, B to A, B to C, C to B are allowed to move one cup directly, and A to C or C to A is allowed. Not done.
Given the initial state of n cups and the integer m, it is possible to determine if all the cups can be stacked together in either the A or C tray within m moves. Create a program that outputs the minimum number of movements in some cases and -1 in cases where it is not possible.
On the first line of the input file, n and m are written in this order with a space as the delimiter. 1 β€ n β€ 15 and 1 β€ m β€ 15000000. On the 2nd, 3rd, and 4th lines, some integers from 1 to n are divided into 3 groups and arranged in ascending order within each group. .. However, the number of them is written at the beginning of each line (before those integers). The integers on the second line (except the first one) represent the size of each cup stacked on tray A. Similarly, the integers on the third line (except the first one) represent the size of each cup stacked on tray B, and the integers on the fourth line (excluding the first one). (Except one) represents the size of each cup stacked on tray C.
Input example 1 | Input example 2 | Input example 3 | Input example 4
--- | --- | --- | ---
|
3 10 | 4 20 | 2 5 | 3 3
0 | 2 1 2 | 2 1 2 | 0
1 1 | 1 3 | 0 | 1 1
2 2 3 | 1 4 | 0 | 2 2 3
Output example 1 | Output example 2 | Output example 3 | Output example 4
9 | 3 | 0 | -1
input
The input consists of multiple datasets. Input ends when both n and m are 0. The number of datasets does not exceed 5.
output
For each dataset, the number of moves or -1 is output on one line.
Example
Input
3 10
0
1 1
2 2 3
4 20
2 1 2
1 3
1 4
2 5
2 1 2
0
0
3 3
0
1 1
2 2 3
0 0
Output
9
3
0
-1
### Response
```cpp
#include <iostream>
#include <stack>
#include <cstring>
using namespace std;
int n, m, cnt;
int pos[20], tmpPos[20];
void copyPos(int *fromPos, int *toPos){
for(int i = 0; i < 20; i++){
toPos[i] = fromPos[i];
}
}
void toC(int x);
void toA(int x){
if(pos[x] == 0){
return;
}
if(pos[x] == 2){
//xγγ倧γγγ³γγγε
¨γ¦Aγ«η§»γ
for(int i = x + 1; i < n; i++){
toA(i);
if(cnt > m) return;
}
//Bγ«γ³γγxγ移γ
cnt++;
if(cnt > m) return;
pos[x] = 1;
}
if(pos[x] == 1){
//xγγ倧γγγ³γγγε
¨γ¦Cγ«η§»γ
for(int i = x + 1; i < n; i++){
toC(i);
if(cnt > m) return;
}
//Aγ«γ³γγxγ移γ
cnt++;
if(cnt > m) return;
pos[x] = 0;
}
}
void toC(int x){
if(pos[x] == 2){
return;
}
if(pos[x] == 0){
//xγγ倧γγγ³γγγε
¨γ¦Cγ«η§»γ
for(int i = x + 1; i < n; i++){
toC(i);
if(cnt > m) return;
}
//Bγ«γ³γγxγ移γ
cnt++;
if(cnt > m) return;
pos[x] = 1;
}
if(pos[x] == 1){
//xγγ倧γγγ³γγγε
¨γ¦Aγ«η§»γ
for(int i = x + 1; i < n; i++){
toA(i);
if(cnt > m) return;
}
//Cγ«γ³γγxγ移γ
cnt++;
if(cnt > m) return;
pos[x] = 2;
}
}
void solve(){
int res = m + 1;
copyPos(pos, tmpPos);
cnt = 0;
for(int i = 0; i < n; i++){
toA(i);
if(cnt > m) break;
}
res = min(res, cnt);
copyPos(tmpPos, pos);
cnt = 0;
for(int i = 0; i < n; i++){
toC(i);
if(cnt > m) break;
}
res = min(res, cnt);
cout << (res == m + 1 ? -1 : res) << endl;
}
int main(){
while(cin >> n >> m, n || m){
for(int i = 0; i < 3; i++){
int a;
cin >> a;
for(int j = 0; j < a; j++){
int x;
cin >> x;
x--;
pos[x] = i;
}
}
solve();
}
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
Denis was very sad after Nastya rejected him. So he decided to walk through the gateways to have some fun. And luck smiled at him! When he entered the first courtyard, he met a strange man who was selling something.
Denis bought a mysterious item and it was... Random permutation generator! Denis could not believed his luck.
When he arrived home, he began to study how his generator works and learned the algorithm. The process of generating a permutation consists of n steps. At the i-th step, a place is chosen for the number i (1 β€ i β€ n). The position for the number i is defined as follows:
* For all j from 1 to n, we calculate r_j β the minimum index such that j β€ r_j β€ n, and the position r_j is not yet occupied in the permutation. If there are no such positions, then we assume that the value of r_j is not defined.
* For all t from 1 to n, we calculate count_t β the number of positions 1 β€ j β€ n such that r_j is defined and r_j = t.
* Consider the positions that are still not occupied by permutation and among those we consider the positions for which the value in the count array is maximum.
* The generator selects one of these positions for the number i. The generator can choose any position.
Let's have a look at the operation of the algorithm in the following example:
<image>
Let n = 5 and the algorithm has already arranged the numbers 1, 2, 3 in the permutation. Consider how the generator will choose a position for the number 4:
* The values of r will be r = [3, 3, 3, 4, Γ], where Γ means an indefinite value.
* Then the count values will be count = [0, 0, 3, 1, 0].
* There are only two unoccupied positions in the permutation: 3 and 4. The value in the count array for position 3 is 3, for position 4 it is 1.
* The maximum value is reached only for position 3, so the algorithm will uniquely select this position for number 4.
Satisfied with his purchase, Denis went home. For several days without a break, he generated permutations. He believes that he can come up with random permutations no worse than a generator. After that, he wrote out the first permutation that came to mind p_1, p_2, β¦, p_n and decided to find out if it could be obtained as a result of the generator.
Unfortunately, this task was too difficult for him, and he asked you for help. It is necessary to define whether the written permutation could be obtained using the described algorithm if the generator always selects the position Denis needs.
Input
The first line contains a single integer t (1 β€ t β€ 10^5) β the number of test cases. Then the descriptions of the test cases follow.
The first line of the test case contains a single integer n (1 β€ n β€ 10^5) β the size of the permutation.
The second line of the test case contains n different integers p_1, p_2, β¦, p_n (1 β€ p_i β€ n) β the permutation written by Denis.
It is guaranteed that the sum of n over all test cases doesn't exceed 10^5.
Output
Print "Yes" if this permutation could be obtained as a result of the generator. Otherwise, print "No".
All letters can be displayed in any case.
Example
Input
5
5
2 3 4 5 1
1
1
3
1 3 2
4
4 2 3 1
5
1 5 2 4 3
Output
Yes
Yes
No
Yes
No
Note
Let's simulate the operation of the generator in the first test.
At the 1 step, r = [1, 2, 3, 4, 5], count = [1, 1, 1, 1, 1]. The maximum value is reached in any free position, so the generator can choose a random position from 1 to 5. In our example, it chose 5.
At the 2 step, r = [1, 2, 3, 4, Γ], count = [1, 1, 1, 1, 0]. The maximum value is reached in positions from 1 to 4, so the generator can choose a random position among them. In our example, it chose 1.
At the 3 step, r = [2, 2, 3, 4, Γ], count = [0, 2, 1, 1, 0]. The maximum value is 2 and is reached only at the 2 position, so the generator will choose this position.
At the 4 step, r = [3, 3, 3, 4, Γ], count = [0, 0, 3, 1, 0]. The maximum value is 3 and is reached only at the 3 position, so the generator will choose this position.
At the 5 step, r = [4, 4, 4, 4, Γ], count = [0, 0, 0, 4, 0]. The maximum value is 4 and is reached only at the 4 position, so the generator will choose this position.
In total, we got a permutation of 2, 3, 4, 5, 1, that is, a generator could generate it.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(void) {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int i, j, n, m, k, a[524288], b[524288], tg, st, p, fl, t;
scanf("%d", &t);
while (t > 0) {
t--;
fl = 1;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
b[a[i]] = i;
}
for (i = 2; i <= n; i++) {
if (b[i - 1] + 1 < b[i]) {
fl = 0;
break;
}
}
tg = n;
st = 1;
for (i = 2; i <= n; i++) {
if (b[i - 1] > b[i]) {
if (b[i - 1] != tg) {
fl = 0;
break;
}
tg = b[st] - 1;
st = i;
}
}
if (fl == 1) {
cout << "Yes" << '\n';
} else {
cout << "No" << '\n';
}
}
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
A calculator scholar has discovered a strange life form called an electronic fly that lives in electronic space. While observing the behavior of the electronic flies, the electronic flies at the (x, y, z) point in this space then move to (x', y', z') indicated by the following rules. I found out.
<image>
However, a1, m1, a2, m2, a3, m3 are positive integers determined for each individual electronic fly. A mod B is the remainder of the positive integer A divided by the positive integer B.
Further observation revealed that some electronic flies always return to (1,1,1) shortly after being placed at (1,1,1). Such flies were named return flies (1).
Create a program that takes the data of the return fly as input and outputs the minimum number of movements (> 0) that return to (1,1,1). Note that 1 <a1, m1, a2, m2, a3, m3 <215.
(1) Returns when a1 and m1, a2 and m2, a3 and m3 are relatively prime (common divisor 1), respectively.
Input
Given multiple datasets. Each dataset is given in the following format:
a1 m1 a2 m2 a3 m3
The input ends with a line containing 6 0s. The number of datasets does not exceed 50.
Output
For each dataset, output the minimum number of moves (integer) that return to (1,1,1) on one line.
Example
Input
2 5 3 7 6 13
517 1024 746 6561 4303 3125
0 0 0 0 0 0
Output
12
116640000
### Response
```cpp
#include <cstdio>
using namespace std;
typedef long long int LLI;
LLI gcd(LLI a, LLI b) {
int c, d, t;
c = a;
d = b;
while (1) {
t = c % d;
if (!t) break;
c = d;
d = t;
}
return d;
}
LLI lcm(int a, int b) {
int c = gcd(a, b);
return (LLI) a * b / c;
}
int main() {
LLI a[3], m[3], b[3];
LLI c, s, x;
while (1) {
scanf("%lld %lld %lld %lld %lld %lld", &a[0], &m[0], &a[1], &m[1], &a[2], &m[2]);
if (!a[0] && !m[0] && !a[1] && !m[1] && !a[2] && !m[2]) break;
for (int i=0; i<3; i++) {
s = 1;
c = 0;
do {
s *= a[i];
s %= m[i];
++c;
} while (s!=1);
b[i] = c;
}
x = lcm(b[0], b[1]);
x = lcm(b[2], x);
printf("%lld\n", x);
}
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
On a random day, Neko found n treasure chests and m keys. The i-th chest has an integer a_i written on it and the j-th key has an integer b_j on it. Neko knows those chests contain the powerful mysterious green Grapes, thus Neko wants to open as many treasure chests as possible.
The j-th key can be used to unlock the i-th chest if and only if the sum of the key number and the chest number is an odd number. Formally, a_i + b_j β‘ 1 \pmod{2}. One key can be used to open at most one chest, and one chest can be opened at most once.
Find the maximum number of chests Neko can open.
Input
The first line contains integers n and m (1 β€ n, m β€ 10^5) β the number of chests and the number of keys.
The second line contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9) β the numbers written on the treasure chests.
The third line contains m integers b_1, b_2, β¦, b_m (1 β€ b_i β€ 10^9) β the numbers written on the keys.
Output
Print the maximum number of chests you can open.
Examples
Input
5 4
9 14 6 2 11
8 4 7 20
Output
3
Input
5 1
2 4 6 8 10
5
Output
1
Input
1 4
10
20 30 40 50
Output
0
Note
In the first example, one possible way to unlock 3 chests is as follows:
* Use first key to unlock the fifth chest,
* Use third key to unlock the second chest,
* Use fourth key to unlock the first chest.
In the second example, you can use the only key to unlock any single chest (note that one key can't be used twice).
In the third example, no key can unlock the given chest.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m, even = 0, odd = 0, e = 0, o = 0;
cin >> n >> m;
vector<long long int> a, b;
for (int i = 0; i < n; i++) {
long long int x;
cin >> x;
a.push_back(x);
if (x % 2 == 0) {
e++;
} else {
o++;
}
}
for (int i = 0; i < m; i++) {
long long int x;
cin >> x;
b.push_back(x);
if (x % 2 == 0) {
even++;
} else {
odd++;
}
}
long long int EVEN = 0, ODD = 0;
EVEN = min(e, odd);
ODD = min(even, o);
cout << EVEN + ODD << endl;
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
This problem is about imaginary languages BHTML and BCSS, which slightly resemble HTML and CSS. Read the problem statement carefully as the resemblance is rather slight and the problem uses very simplified analogs.
You are given a BHTML document that resembles HTML but is much simpler. It is recorded as a sequence of opening and closing tags. A tag that looks like "<tagname>" is called an opening tag and a tag that looks like "</tagname>" is called a closing tag. Besides, there are self-closing tags that are written as "<tagname/>" and in this problem they are fully equivalent to "<tagname></tagname>". All tagnames in this problem are strings consisting of lowercase Latin letters with length from 1 to 10 characters. Tagnames of different tags may coincide.
The document tags form a correct bracket sequence, that is, we can obtain an empty sequence from the given one using the following operations:
* remove any self-closing tag "<tagname/>",
* remove a pair of an opening and a closing tag that go consecutively (in this order) and have the same names. In other words, remove substring "<tagname></tagname>".
For example, you may be given such document: "<header><p><a/><b></b></p></header><footer></footer>" but you may not be given documents "<a>", "<a></b>", "</a><a>" or "<a><b></a></b>".
Obviously, for any opening tag there is the only matching closing one β each such pair is called an element. A self-closing tag also is an element. Let's consider that one element is nested inside another one, if tags of the first element are between tags of the second one. An element is not nested to itself. For instance, in the example above element "b" is nested in "header" and in "p", but it isn't nested in "a" and "footer", also it isn't nested to itself ("b"). Element "header" has three elements nested in it, and "footer" has zero.
We need the BCSS rules to apply styles when displaying elements of the BHTML documents. Each rule is recorded as a subsequence of words "x1 x2 ... xn". This rule has effect over all such elements t, which satisfy both conditions from the list:
* there is a sequence of nested elements with tagnames "x1", "x2", ..., "xn" (that is, the second element is nested in the first one, the third element is nested in the second one and so on),
* this sequence ends with element t (i.e. tagname of element t equals "xn").
For example, element "b" meets the conditions of the rule "a b" if for element "b" exists element "a" in which it is nested. Element "c" meets the conditions of the rule "a b b c", if three elements exist: "a", "b", "b", and in the chain "a"-"b"-"b"-"c" each following element is nested in the previous one.
Given a BHTML document and a set of BCSS rules, write a program that determines the number of elements that meet the conditions of each rule.
Input
The first line of the input contains a BHTML-document. The document has length from 4 to 106 characters. The document has a correct structure, doesn't contain spaces or any other unnecessary characters. Tagnames consist of lowercase Latin letters, their lengths are from 1 to 10 characters.
The second line contains an integer m (1 β€ m β€ 200) β the number of queries. Then m lines contain the queries, one per line. Each query is a sequence x1, x2, ..., xn, where xi is the i-th element of the query, and n (1 β€ n β€ 200) is the number of elements in the query. The elements are separated by single spaces. Each query doesn't begin with and doesn't end with a space. Each query element is a sequence of lowercase Latin letters with length from 1 to 10.
Output
Print m lines, the j-th line should contain the number of elements of the document that correspond to the j-th BCSS-rule. If there are no such elements at all, print on the line 0.
Examples
Input
<a><b><b></b></b></a><a><b></b><b><v/></b></a><b></b>
4
a
a b b
a b
b a
Output
2
1
4
0
Input
<b><aa/></b><aa><b/><b/></aa>
5
aa b
b
aa
b aa
a
Output
2
3
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:260108864")
using namespace std;
char s[1000005];
int lenS;
int d[1000001];
int query[1000001];
int haveTo[1000001];
int n;
int now;
int qN;
map<string, int> m;
void prepare() {
now = 0;
int k(0);
for (int i(0); i <= ((int)(lenS)-1); ++i) {
++i;
string tag;
int upTo(0);
bool close = false;
while (s[i + upTo] != '>') {
if (s[i + upTo] != '/') tag += s[i + upTo];
++upTo;
}
if (m[tag] == 0) m[tag] = ++k;
if (s[i] == '/') close = true;
if (s[i + upTo - 1] == '/') {
d[now++] = m[tag];
d[now++] = -m[tag];
} else if (close)
d[now++] = -m[tag];
else
d[now++] = m[tag];
i += upTo;
}
}
void prepareQ() {
qN = 0;
for (int i(0); i <= ((int)(lenS)-1); ++i) {
int upTo(0);
string tag;
while (s[i + upTo] != 0 && s[i + upTo] != ' ') tag += s[i + upTo], ++upTo;
int tagN(0);
if (m.count(tag) != 0) tagN = m[tag];
query[qN++] = tagN;
i += upTo;
}
}
int calc() {
int nowSt(1);
haveTo[0] = 0;
int res(0);
for (int i(0); i <= ((int)(now)-1); ++i) {
if (d[i] < 0)
--nowSt;
else {
if (d[i] == query[haveTo[nowSt - 1]])
haveTo[nowSt] = haveTo[nowSt - 1] + 1;
else
haveTo[nowSt] = haveTo[nowSt - 1];
if (haveTo[nowSt] == qN) ++res, haveTo[nowSt] -= 1;
++nowSt;
}
}
return res;
}
int main() {
gets(s);
lenS = strlen(s);
prepare();
int n;
scanf("%d\n", &n);
for (int i(0); i <= ((int)(n)-1); ++i) {
gets(s);
lenS = strlen(s);
prepareQ();
printf("%d\n", calc());
}
return 0;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
Mishka wants to buy some food in the nearby shop. Initially, he has s burles on his card.
Mishka can perform the following operation any number of times (possibly, zero): choose some positive integer number 1 β€ x β€ s, buy food that costs exactly x burles and obtain βx/10β burles as a cashback (in other words, Mishka spends x burles and obtains βx/10β back). The operation βa/bβ means a divided by b rounded down.
It is guaranteed that you can always buy some food that costs x for any possible value of x.
Your task is to say the maximum number of burles Mishka can spend if he buys food optimally.
For example, if Mishka has s=19 burles then the maximum number of burles he can spend is 21. Firstly, he can spend x=10 burles, obtain 1 burle as a cashback. Now he has s=10 burles, so can spend x=10 burles, obtain 1 burle as a cashback and spend it too.
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.
The next t lines describe test cases. Each test case is given on a separate line and consists of one integer s (1 β€ s β€ 10^9) β the number of burles Mishka initially has.
Output
For each test case print the answer on it β the maximum number of burles Mishka can spend if he buys food optimally.
Example
Input
6
1
10
19
9876
12345
1000000000
Output
1
11
21
10973
13716
1111111111
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 100000000000;
long long Ceil(long long a, long long b) { return (a / b) + ((a % b) != 0); }
int main() {
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
long long cb = 0, rem = 0, total = 0;
while (n / 10 > 0) {
cb = n / 10;
rem = n % 10;
total += cb * 10;
n = cb + rem;
}
cout << total + (n % 10) << endl;
}
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
For a connected undirected weighted graph G, MST (minimum spanning tree) is a subgraph of G that contains all of G's vertices, is a tree, and sum of its edges is minimum possible.
You are given a graph G. If you run a MST algorithm on graph it would give you only one MST and it causes other edges to become jealous. You are given some queries, each query contains a set of edges of graph G, and you should determine whether there is a MST containing all these edges or not.
Input
The first line contains two integers n, m (2 β€ n, m β€ 5Β·105, n - 1 β€ m) β the number of vertices and edges in the graph and the number of queries.
The i-th of the next m lines contains three integers ui, vi, wi (ui β vi, 1 β€ wi β€ 5Β·105) β the endpoints and weight of the i-th edge. There can be more than one edges between two vertices. It's guaranteed that the given graph is connected.
The next line contains a single integer q (1 β€ q β€ 5Β·105) β the number of queries.
q lines follow, the i-th of them contains the i-th query. It starts with an integer ki (1 β€ ki β€ n - 1) β the size of edges subset and continues with ki distinct space-separated integers from 1 to m β the indices of the edges. It is guaranteed that the sum of ki for 1 β€ i β€ q does not exceed 5Β·105.
Output
For each query you should print "YES" (without quotes) if there's a MST containing these edges and "NO" (of course without quotes again) otherwise.
Example
Input
5 7
1 2 2
1 3 2
2 3 1
2 4 1
3 4 1
3 5 2
4 5 2
4
2 3 4
3 3 4 5
2 1 7
2 1 2
Output
YES
NO
YES
NO
Note
This is the graph of sample:
<image>
Weight of minimum spanning tree on this graph is 6.
MST with edges (1, 3, 4, 6), contains all of edges from the first query, so answer on the first query is "YES".
Edges from the second query form a cycle of length 3, so there is no spanning tree including these three edges. Thus, answer is "NO".
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAXBUF = 10000;
char buf[MAXBUF], *ps = buf, *pe = buf + 1;
inline bool isdigit(const char& n) { return (n >= '0' && n <= '9'); }
inline void rnext() {
if (++ps == pe)
pe = (ps = buf) +
fread(buf, sizeof(char), sizeof(buf) / sizeof(char), stdin);
}
template <class T>
inline bool in(T& ans) {
ans = 0;
T f = 1;
if (ps == pe) return false;
do {
rnext();
if ('-' == *ps) f = -1;
} while (!isdigit(*ps) && ps != pe);
if (ps == pe) return false;
do {
ans = (ans << 1) + (ans << 3) + *ps - 48;
rnext();
} while (isdigit(*ps) && ps != pe);
ans *= f;
return true;
}
const int MAXOUT = 10000;
char bufout[MAXOUT], outtmp[50], *pout = bufout, *pend = bufout + MAXOUT;
inline void write() {
fwrite(bufout, sizeof(char), pout - bufout, stdout);
pout = bufout;
}
inline void out_char(char c) {
*(pout++) = c;
if (pout == pend) write();
}
inline void out_str(char* s) {
while (*s) {
*(pout++) = *(s++);
if (pout == pend) write();
}
}
template <class T>
inline void out_int(T x) {
if (!x) {
out_char('0');
return;
}
if (x < 0) x = -x, out_char('-');
int len = 0;
while (x) {
outtmp[len++] = x % 10 + 48;
x /= 10;
}
outtmp[len] = 0;
for (int i = 0, j = len - 1; i < j; i++, j--) swap(outtmp[i], outtmp[j]);
out_str(outtmp);
}
template <typename T, typename... T2>
inline int in(T& value, T2&... value2) {
in(value);
return in(value2...);
}
const double eps = 1e-9;
const int maxn = 5e5 + 10;
const int INF = 0x3f3f3f3f;
const int mod = 1e9 + 7;
int N, M, tmp, K, Q;
struct Edge {
int u, v, w, id;
} edge[maxn];
struct node {
int w, id, pointer;
friend bool operator<(node a, node b) { return a.w > b.w; }
};
vector<int> query[maxn];
priority_queue<node> P;
int Back[maxn][2];
int cnt;
int tree[maxn];
int Size[maxn];
int ans[maxn], ID[maxn];
void init() {
for (register int i = 1; i <= N; i++) tree[i] = i, Size[i] = 1;
}
int find(int p) {
if (p == tree[p]) return p;
return find(tree[p]);
}
bool Union(int u, int v) {
u = find(u);
v = find(v);
if (u == v) return false;
if (Size[u] > Size[v]) swap(u, v);
tree[u] = v;
Size[v] += Size[u];
Back[++cnt][0] = u;
Back[cnt][1] = v;
return true;
}
void Cancel() {
while (cnt) {
int u = Back[cnt][0];
int v = Back[cnt--][1];
tree[u] = u;
Size[v] -= Size[u];
}
}
bool cmp(Edge a, Edge b) { return a.w < b.w; }
int main() {
in(N, M);
init();
for (register int i = 1; i <= M; i++)
in(edge[i].u, edge[i].v, edge[i].w), edge[i].id = i;
sort(edge + 1, edge + M + 1, cmp);
for (register int i = 1; i <= M; i++) ID[edge[i].id] = i;
in(Q);
for (register int i = 1; i <= Q; i++) {
in(tmp);
while (tmp--) {
int t;
in(t);
t = ID[t];
query[i].push_back(t);
}
sort(query[i].begin(), query[i].end());
node h;
h.id = i;
h.pointer = 0;
h.w = query[i][0];
P.push(h);
}
for (int i = 1; i <= M;) {
int W = edge[i].w;
int j = i + 1;
for (; j <= M && edge[j].w == edge[i].w; j++)
;
j--;
while (!P.empty()) {
node x = P.top();
if (x.w > j) break;
P.pop();
int v = x.id;
while (x.pointer < query[v].size() && query[v][x.pointer] <= j) {
if (!Union(edge[query[v][x.pointer]].u, edge[query[v][x.pointer]].v))
break;
x.pointer++;
}
Cancel();
if (x.pointer == query[v].size()) {
ans[x.id] = 1;
continue;
}
x.w = query[v][x.pointer];
if (x.w > j) P.push(x);
}
for (; i <= j; i++) Union(edge[i].u, edge[i].v);
cnt = 0;
}
for (register int i = 1; i <= Q; i++) {
if (ans[i] == 1)
puts("YES");
else
puts("NO");
}
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
Bob likes to draw camels: with a single hump, two humps, three humps, etc. He draws a camel by connecting points on a coordinate plane. Now he's drawing camels with t humps, representing them as polylines in the plane. Each polyline consists of n vertices with coordinates (x1, y1), (x2, y2), ..., (xn, yn). The first vertex has a coordinate x1 = 1, the second β x2 = 2, etc. Coordinates yi might be any, but should satisfy the following conditions:
* there should be t humps precisely, i.e. such indexes j (2 β€ j β€ n - 1), so that yj - 1 < yj > yj + 1,
* there should be precisely t - 1 such indexes j (2 β€ j β€ n - 1), so that yj - 1 > yj < yj + 1,
* no segment of a polyline should be parallel to the Ox-axis,
* all yi are integers between 1 and 4.
For a series of his drawings of camels with t humps Bob wants to buy a notebook, but he doesn't know how many pages he will need. Output the amount of different polylines that can be drawn to represent camels with t humps for a given number n.
Input
The first line contains a pair of integers n and t (3 β€ n β€ 20, 1 β€ t β€ 10).
Output
Output the required amount of camels with t humps.
Examples
Input
6 1
Output
6
Input
4 2
Output
0
Note
In the first sample test sequences of y-coordinates for six camels are: 123421, 123431, 123432, 124321, 134321 ΠΈ 234321 (each digit corresponds to one value of yi).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long Univ = 0;
;
int n, t, vec[25];
void Rec(int i, int ach, int acs) {
if (i > 3) {
if (vec[i - 2] > vec[i - 1] && vec[i - 2] > vec[i - 3]) ach++;
if (vec[i - 2] < vec[i - 1] && vec[i - 2] < vec[i - 3]) acs++;
}
if (ach > t || acs == t) return;
if ((t - ach) * 2 - 1 > n - i) return;
if (i == n) {
if (ach == t && acs == t - 1) {
Univ++;
}
return;
}
if (vec[i - 1] < 2) {
if (vec[i - 1] == 0) {
vec[i] = 1, Rec(i + 1, ach, acs);
vec[i] = 2, Rec(i + 1, ach, acs);
vec[i] = 3, Rec(i + 1, ach, acs);
} else {
vec[i] = 0, Rec(i + 1, ach, acs);
vec[i] = 2, Rec(i + 1, ach, acs);
vec[i] = 3, Rec(i + 1, ach, acs);
}
} else {
if (vec[i - 1] == 2) {
vec[i] = 0, Rec(i + 1, ach, acs);
vec[i] = 1, Rec(i + 1, ach, acs);
vec[i] = 3, Rec(i + 1, ach, acs);
} else {
vec[i] = 0, Rec(i + 1, ach, acs);
vec[i] = 1, Rec(i + 1, ach, acs);
vec[i] = 2, Rec(i + 1, ach, acs);
}
}
}
long long vec20[] = {0, 0, 0, 0, 12628, 3715462,
96046590, 468541040, 503245466, 90700276, 0};
long long vec19[] = {0, 0, 0, 1, 32632, 4594423,
69183464, 197939352, 109824208, 5846414, 0};
long long vec18[] = {0, 0, 0, 14, 68640, 4846524,
41920210, 66357900, 15946870, 0, 0};
int main() {
cin >> n >> t;
if (n == 20) {
cout << vec20[t] << endl;
return 0;
} else if (n == 19) {
cout << vec19[t] << endl;
return 0;
} else if (n == 18) {
cout << vec18[t] << endl;
return 0;
}
n++;
vec[0] = -1;
vec[1] = 0, Rec(2, 0, 0);
vec[1] = 1, Rec(2, 0, 0);
vec[1] = 2, Rec(2, 0, 0);
vec[1] = 3, Rec(2, 0, 0);
cout << Univ << endl;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
Problem
Gaccho owns an N-sided field and M potatoes. Each field is numbered from 1 to N. Gaccho wants to increase the number of potatoes by planting and harvesting potatoes in the field.
Gaccho lives alone and can only manage fields up to the K side. In addition, the soil condition and area of ββeach field vary, and the number of potatoes harvested and the number of potatoes that can be planted also vary. When potatoes are planted in field i, ai potatoes can be harvested for each potato planted in field i one year later. However, only bi potatoes can be planted in the field i at the maximum.
When you plant M or less potatoes in a field within K side, please find the maximum number of potatoes you can own one year later.
Constraints
* 1 β€ N β€ 15
* 1 β€ M β€ 104
* 1 β€ K β€ min (N, 3)
* 1 β€ ai β€ 103
* 1 β€ bi β€ 104
Input
The input is given in the following format.
NMK
a1 a2 ... aN
b1 b2 ... bN
Three integers N, M, K are given on the first line, separated by blanks.
N integers ai are given on the second line, separated by blanks.
N integers bi are given on the third line, separated by blanks.
Output
Output the maximum number of potatoes in one line.
Examples
Input
5 100 3
2 3 4 5 6
50 40 20 10 5
Output
280
Input
5 100 3
2 3 4 5 100
50 40 20 10 1
Output
339
### Response
```cpp
#include<bits/stdc++.h>
#define int long long int
using namespace std;
int n, m, k;
int a[20], b[20];
int ah[4];
int ans = 0;
int bfs(int times)
{
int ret = 0;
if(times < k){
for(int i = 1; i <= n; i++){
ah[times] = i;
ret = max(ret, bfs(times + 1));
}
}
else{
for(int i = 1; i < k; i++){
if(ah[0] == ah[i]){
return 0;
}
}
if(k == 3 && ah[1] == ah[2]){
return 0;
}
int remain = m;
for(int i = 0; i < k; i++){
ret += a[ah[i]] * min(remain, b[ah[i]]);
remain = remain <= b[ah[i]] ? 0 : remain - b[ah[i]];
}
ret += remain;
}
return ret;
}
signed main()
{
cin >> n >> m >> k;
for(int i = 1; i <= n; i++){
cin >> a[i];
}
for(int i = 1; i <= n; i++){
cin >> b[i];
}
cout << bfs(0) << endl;
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
Kuroni has n daughters. As gifts for them, he bought n necklaces and n bracelets:
* the i-th necklace has a brightness a_i, where all the a_i are pairwise distinct (i.e. all a_i are different),
* the i-th bracelet has a brightness b_i, where all the b_i are pairwise distinct (i.e. all b_i are different).
Kuroni wants to give exactly one necklace and exactly one bracelet to each of his daughters. To make sure that all of them look unique, the total brightnesses of the gifts given to each daughter should be pairwise distinct. Formally, if the i-th daughter receives a necklace with brightness x_i and a bracelet with brightness y_i, then the sums x_i + y_i should be pairwise distinct. Help Kuroni to distribute the gifts.
For example, if the brightnesses are a = [1, 7, 5] and b = [6, 1, 2], then we may distribute the gifts as follows:
* Give the third necklace and the first bracelet to the first daughter, for a total brightness of a_3 + b_1 = 11.
* Give the first necklace and the third bracelet to the second daughter, for a total brightness of a_1 + b_3 = 3.
* Give the second necklace and the second bracelet to the third daughter, for a total brightness of a_2 + b_2 = 8.
Here is an example of an invalid distribution:
* Give the first necklace and the first bracelet to the first daughter, for a total brightness of a_1 + b_1 = 7.
* Give the second necklace and the second bracelet to the second daughter, for a total brightness of a_2 + b_2 = 8.
* Give the third necklace and the third bracelet to the third daughter, for a total brightness of a_3 + b_3 = 7.
This distribution is invalid, as the total brightnesses of the gifts received by the first and the third daughter are the same. Don't make them this upset!
Input
The input consists of multiple test cases. The first line contains an integer t (1 β€ t β€ 100) β the number of test cases. The description of the test cases follows.
The first line of each test case contains a single integer n (1 β€ n β€ 100) β the number of daughters, necklaces and bracelets.
The second line of each test case contains n distinct integers a_1, a_2, ..., a_n (1 β€ a_i β€ 1000) β the brightnesses of the necklaces.
The third line of each test case contains n distinct integers b_1, b_2, ..., b_n (1 β€ b_i β€ 1000) β the brightnesses of the bracelets.
Output
For each test case, print a line containing n integers x_1, x_2, ..., x_n, representing that the i-th daughter receives a necklace with brightness x_i. In the next line print n integers y_1, y_2, ..., y_n, representing that the i-th daughter receives a bracelet with brightness y_i.
The sums x_1 + y_1, x_2 + y_2, ..., x_n + y_n should all be distinct. The numbers x_1, ..., x_n should be equal to the numbers a_1, ..., a_n in some order, and the numbers y_1, ..., y_n should be equal to the numbers b_1, ..., b_n in some order.
It can be shown that an answer always exists. If there are multiple possible answers, you may print any of them.
Example
Input
2
3
1 8 5
8 4 5
3
1 7 5
6 1 2
Output
1 8 5
8 4 5
5 1 7
6 2 1
Note
In the first test case, it is enough to give the i-th necklace and the i-th bracelet to the i-th daughter. The corresponding sums are 1 + 8 = 9, 8 + 4 = 12, and 5 + 5 = 10.
The second test case is described in the statement.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int test;
cin >> test;
for (int tst = 1; tst <= test; ++tst) {
int n;
cin >> n;
vector<int> a(n);
vector<int> b(n);
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i < n; ++i) cin >> b[i];
sort(a.begin(), a.end());
sort(b.begin(), b.end());
for (int i = 0; i < n; ++i) cout << a[i] << " ";
cout << endl;
for (int i = 0; i < n; ++i) cout << b[i] << " ";
cout << endl;
}
return 0;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
You are given a table consisting of n rows and m columns. Each cell of the table contains a number, 0 or 1. In one move we can choose some row of the table and cyclically shift its values either one cell to the left, or one cell to the right.
To cyclically shift a table row one cell to the right means to move the value of each cell, except for the last one, to the right neighboring cell, and to move the value of the last cell to the first cell. A cyclical shift of a row to the left is performed similarly, but in the other direction. For example, if we cyclically shift a row "00110" one cell to the right, we get a row "00011", but if we shift a row "00110" one cell to the left, we get a row "01100".
Determine the minimum number of moves needed to make some table column consist only of numbers 1.
Input
The first line contains two space-separated integers: n (1 β€ n β€ 100) β the number of rows in the table and m (1 β€ m β€ 104) β the number of columns in the table. Then n lines follow, each of them contains m characters "0" or "1": the j-th character of the i-th line describes the contents of the cell in the i-th row and in the j-th column of the table.
It is guaranteed that the description of the table contains no other characters besides "0" and "1".
Output
Print a single number: the minimum number of moves needed to get only numbers 1 in some column of the table. If this is impossible, print -1.
Examples
Input
3 6
101010
000100
100000
Output
3
Input
2 3
111
000
Output
-1
Note
In the first sample one way to achieve the goal with the least number of moves is as follows: cyclically shift the second row to the right once, then shift the third row to the left twice. Then the table column before the last one will contain only 1s.
In the second sample one can't shift the rows to get a column containing only 1s.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int cost[101][10008];
int data[101][10008];
int main() {
int n, m;
cin >> n >> m;
int sol = -1;
for (int i = 1; i <= n; ++i) {
sol = -1;
for (int j = 1; j <= m; ++j) {
char ch;
cin >> ch;
if (ch == '1')
data[i][j] = 1, sol = 1, cost[i][j] = 0;
else
data[i][j] = 0;
}
if (sol == -1) {
cout << "-1";
return 0;
}
}
for (int i = 1; i <= n; ++i) {
int lc[10005], rc[10005], l, r, cc, c = 0;
for (int j = 1; j <= m; ++j) {
if (data[i][j] == 1) {
l = j;
break;
}
}
for (int j = m; j >= 1; --j) {
if (data[i][j] == 1) {
r = j;
break;
}
}
for (int j = l; j <= r; ++j) {
if (data[i][j] == 1)
c = 0;
else
++c;
lc[j] = c;
}
for (int j = r; j >= l; --j) {
if (data[i][j] == 1)
c = 0;
else
++c;
rc[j] = c;
cost[i][j] = min(lc[j], rc[j]);
}
for (int j = 1; j < l; ++j) {
cost[i][j] = min(m - r + j, l - j);
}
for (int j = r + 1; j <= m; ++j) {
cost[i][j] = min(j - r, m - j + l);
}
}
unsigned long long int ans = 100000000;
for (int j = 1; j <= m; ++j) {
unsigned long long int sum = 0;
for (int i = 1; i <= n; ++i) sum += cost[i][j];
ans = min(ans, sum);
}
cout << ans;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
Mr. Bill is shopping at the store. There are some coins in his wallet (10-yen coins, 50-yen coins, 100-yen coins, 500-yen coins), but he is now trying to consume as much of this coin as possible. In other words, by paying for the goods with an appropriate number of coins, we are trying to minimize the total number of coins after receiving the change.
Fortunately, the clerk at this store is so disciplined and kind that change is always delivered in the best possible way. Therefore, for example, five 100-yen coins will not be given instead of one 500-yen coin. You can also take out 5 10-yen coins and receive 50-yen coins as change. However, you must not pay the coins of the same type as the coins you issued so that they will be returned as change. For example, if a 10-yen coin is paid out and another 10-yen coin is returned as change, a completely meaningless exchange will occur.
However, Mr. Bill was not good at calculating, so he could not find out how many coins he should actually use. So he asked you for help. Your job is to write a program to determine the type and number of coins to use based on the number of coins in his wallet and the payment price. The clerk does not use banknotes for change.
Input
The input contains several test cases.
Each test case consists of two lines. The first line contains a single integer representing Mr. Bill's payment in yen. The second line contains four integers, which in turn represent the number of 10-yen coins, 50-yen coins, 100-yen coins, and 500-yen coins in your wallet.
The payment amount is always in units of 10 yen. That is, the one-yen place of the payment amount is always 0. You can also assume that you can only have up to 20 coins of the same type in your wallet. No non-payable cases are given during input.
The end of input is represented by a line containing a single 0.
Output
For each test case, print out the type and number of coins that Mr. Bill should use.
Each line of output contains the two integers ci and ki. This means using ki coins for ci yen when paying. When using multiple types of coins, output as many lines as necessary in order from the smallest ci. Refer to the output example below.
The output must not include extra space. Separate consecutive test cases with a blank line.
Example
Input
160
1 1 2 0
160
1 0 2 10
0
Output
10 1
50 1
100 1
10 1
100 2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using uint = unsigned int;
using lint = long long int;
using ulint = unsigned long long int;
template<class T = int> using V = vector<T>;
template<class T = int> using VV = V< V<T> >;
template<class T, class U> void assign(V<T>& v, int n, const U& a) { v.assign(n, a); }
template<class T, class... Args> void assign(V<T>& v, int n, const Args&... args) { v.resize(n); for (auto&& e : v) assign(e, args...); }
int main() {
cin.tie(nullptr); ios_base::sync_with_stdio(false);
V<> a{10, 50, 100, 500};
bool f = true;
while (true) {
int n; cin >> n;
if (n == 0) break;
V<> c(4); for (int i = 0; i < 4; ++i) cin >> c[i];
int m = inner_product(begin(a), end(a), begin(c), 0) - n;
V<> d(4);
for (int i = 3; i >= 0; --i) {
d[i] = m / a[i];
m -= a[i] * d[i];
}
if (!f) cout << '\n';
f = false;
for (int i = 0; i < 4; ++i) if (c[i] - d[i] > 0) {
cout << a[i] << ' ' << c[i] - d[i] << '\n';
}
}
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
Last summer Peter was at his granny's in the country, when a wolf attacked sheep in the nearby forest. Now he fears to walk through the forest, to walk round the forest, even to get out of the house. He explains this not by the fear of the wolf, but by a strange, in his opinion, pattern of the forest that has n levels, where n is an even number.
In the local council you were given an area map, where the granny's house is marked by point H, parts of dense forest are marked grey (see the picture to understand better).
After a long time at home Peter decided to yield to his granny's persuasions and step out for a breath of fresh air. Being prudent, Peter plans the route beforehand. The route, that Peter considers the most suitable, has the following characteristics:
* it starts and ends in the same place β the granny's house;
* the route goes along the forest paths only (these are the segments marked black in the picture);
* the route has positive length (to step out for a breath of fresh air Peter has to cover some distance anyway);
* the route cannot cross itself;
* there shouldn't be any part of dense forest within the part marked out by this route;
You should find the amount of such suitable oriented routes modulo 1000000009.
<image>
The example of the area map for n = 12 is given in the picture. Since the map has a regular structure, you can construct it for other n by analogy using the example.
Input
The input data contain the only even integer n (2 β€ n β€ 106).
Output
Output the only number β the amount of Peter's routes modulo 1000000009.
Examples
Input
2
Output
10
Input
4
Output
74
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000009;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
vector<long long> cavity_paths(n / 2 - 1, 1);
long long p2 = 4;
for (int i = 1; i < int(cavity_paths.size()); ++i) {
cavity_paths[i] = (cavity_paths[i - 1] + p2) % MOD;
p2 = (p2 << 1) % MOD;
}
vector<long long> left_paths(n / 2);
left_paths[0] = 0;
long long ways_here = 1;
for (int i = 1; i < int(left_paths.size()); ++i) {
ways_here = (ways_here * cavity_paths[i - 1]) % MOD;
left_paths[i] = (left_paths[i - 1] + 4 * ways_here) % MOD;
}
cout << (2 *
(1 + (2 + left_paths[n / 2 - 1]) * (2 + left_paths[n / 2 - 1]))) %
MOD
<< endl;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
Maria is the most active old lady in her house. She was tired of sitting at home. She decided to organize a ceremony against the coronavirus.
She has n friends who are also grannies (Maria is not included in this number). The i-th granny is ready to attend the ceremony, provided that at the time of her appearance in the courtyard there will be at least a_i other grannies there. Note that grannies can come into the courtyard at the same time. Formally, the granny i agrees to come if the number of other grannies who came earlier or at the same time with her is greater than or equal to a_i.
Grannies gather in the courtyard like that.
* Initially, only Maria is in the courtyard (that is, the initial number of grannies in the courtyard is 1). All the remaining n grannies are still sitting at home.
* On each step Maria selects a subset of grannies, none of whom have yet to enter the courtyard. She promises each of them that at the time of her appearance there will be at least a_i other grannies (including Maria) in the courtyard. Maria can call several grannies at once. In this case, the selected grannies will go out into the courtyard at the same moment of time.
* She cannot deceive grannies, that is, the situation when the i-th granny in the moment of appearing in the courtyard, finds that now there are strictly less than a_i other grannies (except herself, but including Maria), is prohibited. Please note that if several grannies appeared in the yard at the same time, then each of them sees others at the time of appearance.
Your task is to find what maximum number of grannies (including herself) Maria can collect in the courtyard for the ceremony. After all, the more people in one place during quarantine, the more effective the ceremony!
Consider an example: if n=6 and a=[1,5,4,5,1,9], then:
* at the first step Maria can call grannies with numbers 1 and 5, each of them will see two grannies at the moment of going out into the yard (note that a_1=1 β€ 2 and a_5=1 β€ 2);
* at the second step, Maria can call grannies with numbers 2, 3 and 4, each of them will see five grannies at the moment of going out into the yard (note that a_2=5 β€ 5, a_3=4 β€ 5 and a_4=5 β€ 5);
* the 6-th granny cannot be called into the yard β therefore, the answer is 6 (Maria herself and another 5 grannies).
Input
The first line contains a single integer t (1 β€ t β€ 10^4) β the number of test cases in the input. Then test cases follow.
The first line of a test case contains a single integer n (1 β€ n β€ 10^5) β the number of grannies (Maria is not included in this number).
The second line contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 2β
10^5).
It is guaranteed that the sum of the values n over all test cases of the input does not exceed 10^5.
Output
For each test case, print a single integer k (1 β€ k β€ n + 1) β the maximum possible number of grannies in the courtyard.
Example
Input
4
5
1 1 2 2 1
6
2 3 4 5 6 7
6
1 5 4 5 1 9
5
1 2 3 5 6
Output
6
1
6
4
Note
In the first test case in the example, on the first step Maria can call all the grannies. Then each of them will see five grannies when they come out. Therefore, Maria and five other grannies will be in the yard.
In the second test case in the example, no one can be in the yard, so Maria will remain there alone.
The third test case in the example is described in the details above.
In the fourth test case in the example, on the first step Maria can call grannies with numbers 1, 2 and 3. If on the second step Maria calls 4 or 5 (one of them), then when a granny appears in the yard, she will see only four grannies (but it is forbidden). It means that Maria can't call the 4-th granny or the 5-th granny separately (one of them). If she calls both: 4 and 5, then when they appear, they will see 4+1=5 grannies. Despite the fact that it is enough for the 4-th granny, the 5-th granny is not satisfied. So, Maria cannot call both the 4-th granny and the 5-th granny at the same time. That is, Maria and three grannies from the first step will be in the yard in total.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
vector<int> v;
map<int, int> mp;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
if (mp[x] == 0) {
v.push_back(x);
}
mp[x]++;
}
sort(v.begin(), v.end());
int curr = 1, ug = 0;
for (int i = 0; i < v.size(); i++) {
ug += mp[v[i]];
if (ug + curr > v[i]) {
curr = ug + curr;
ug = 0;
}
}
cout << curr;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(12);
int t = 1;
cin >> t;
for (int i = 1; i <= t; i++) {
solve();
cout << "\n";
}
return 0;
}
``` |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.