text
stringlengths 424
69.5k
|
|---|
### Prompt
Please create a solution in CPP to the following problem:
After celebrating the midcourse the students of one of the faculties of the Berland State University decided to conduct a vote for the best photo. They published the photos in the social network and agreed on the rules to choose a winner: the photo which gets most likes wins. If multiple photoes get most likes, the winner is the photo that gets this number first.
Help guys determine the winner photo by the records of likes.
Input
The first line of the input contains a single integer n (1 β€ n β€ 1000) β the total likes to the published photoes.
The second line contains n positive integers a1, a2, ..., an (1 β€ ai β€ 1 000 000), where ai is the identifier of the photo which got the i-th like.
Output
Print the identifier of the photo which won the elections.
Examples
Input
5
1 3 2 2 1
Output
2
Input
9
100 200 300 200 100 300 300 100 200
Output
300
Note
In the first test sample the photo with id 1 got two likes (first and fifth), photo with id 2 got two likes (third and fourth), and photo with id 3 got one like (second).
Thus, the winner is the photo with identifier 2, as it got:
* more likes than the photo with id 3;
* as many likes as the photo with id 1, but the photo with the identifier 2 got its second like earlier.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int x = 0;
int y = 0;
int s = 0;
int a[n];
int b[1000] = {0};
int c[1000] = {0};
int i = 0;
int j = 0;
for (i = 0; i < n; i++) {
cin >> a[i];
}
for (i = 0; i < n; i++) {
x = 0;
for (j = i; j < n; j++) {
if (a[i] == a[j]) x++;
}
if (x == y) {
b[s] = a[i];
s++;
}
if (x > y) {
for (int k = 0; k < 1000; k++) b[k] = 0;
s = 0;
b[s] = a[i];
y = x;
s++;
}
}
int z = 0;
for (i = 0; i < n; i++) {
for (j = 0; j < s; j++) {
if (b[j] == a[i]) {
c[j]++;
}
if (c[j] == y) {
z = b[j];
break;
}
}
if (c[j] == y) break;
}
cout << z << endl;
return 0;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
We have a grid with H horizontal rows and W vertical columns. Let (i,j) denote the square at the i-th row from the top and the j-th column from the left.
The square (i, j) has two numbers A_{ij} and B_{ij} written on it.
First, for each square, Takahashi paints one of the written numbers red and the other blue.
Then, he travels from the square (1, 1) to the square (H, W). In one move, he can move from a square (i, j) to the square (i+1, j) or the square (i, j+1). He must not leave the grid.
Let the unbalancedness be the absolute difference of the sum of red numbers and the sum of blue numbers written on the squares along Takahashi's path, including the squares (1, 1) and (H, W).
Takahashi wants to make the unbalancedness as small as possible by appropriately painting the grid and traveling on it.
Find the minimum unbalancedness possible.
Constraints
* 2 \leq H \leq 80
* 2 \leq W \leq 80
* 0 \leq A_{ij} \leq 80
* 0 \leq B_{ij} \leq 80
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
H W
A_{11} A_{12} \ldots A_{1W}
:
A_{H1} A_{H2} \ldots A_{HW}
B_{11} B_{12} \ldots B_{1W}
:
B_{H1} B_{H2} \ldots B_{HW}
Output
Print the minimum unbalancedness possible.
Examples
Input
2 2
1 2
3 4
3 4
2 1
Output
0
Input
2 3
1 10 80
80 10 1
1 2 3
4 5 6
Output
2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int INF=1e9;
int a[80][80],b[80][80];
bool dp[81][81][26000];
template<typename T>
void chmin(T &a,T b){
if(a>b)a=b;
}
signed main(){
int h,w;cin>>h>>w;
for(int i=0;i<h;i++)for(int j=0;j<w;j++)cin>>a[i][j];
for(int i=0;i<h;i++)for(int j=0;j<w;j++)cin>>b[i][j];
dp[0][0][13000]=1;
for(int i=0;i<h;i++){
for(int j=0;j<w;j++){
for(int k=100;k<25000;k++){
if(!dp[i][j][k])continue;
dp[i+1][j][k+a[i][j]-b[i][j]]=dp[i+1][j][k-a[i][j]+b[i][j]]=1;
dp[i][j+1][k+a[i][j]-b[i][j]]=dp[i][j+1][k-a[i][j]+b[i][j]]=1;
}
}
}
int ans=INF;
for(int k=0;k<26000;k++)if(dp[h][w-1][k])chmin(ans,abs(k-13000));
cout<<ans<<endl;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
Any resemblance to any real championship and sport is accidental.
The Berland National team takes part in the local Football championship which now has a group stage. Let's describe the formal rules of the local championship:
* the team that kicked most balls in the enemy's goal area wins the game;
* the victory gives 3 point to the team, the draw gives 1 point and the defeat gives 0 points;
* a group consists of four teams, the teams are ranked by the results of six games: each team plays exactly once with each other team;
* the teams that get places 1 and 2 in the group stage results, go to the next stage of the championship.
In the group stage the team's place is defined by the total number of scored points: the more points, the higher the place is. If two or more teams have the same number of points, then the following criteria are used (the criteria are listed in the order of falling priority, starting from the most important one):
* the difference between the total number of scored goals and the total number of missed goals in the championship: the team with a higher value gets a higher place;
* the total number of scored goals in the championship: the team with a higher value gets a higher place;
* the lexicographical order of the name of the teams' countries: the country with the lexicographically smaller name gets a higher place.
The Berland team plays in the group where the results of 5 out of 6 games are already known. To be exact, there is the last game left. There the Berand national team plays with some other team. The coach asks you to find such score X:Y (where X is the number of goals Berland scored and Y is the number of goals the opponent scored in the game), that fulfills the following conditions:
* X > Y, that is, Berland is going to win this game;
* after the game Berland gets the 1st or the 2nd place in the group;
* if there are multiple variants, you should choose such score X:Y, where value X - Y is minimum;
* if it is still impossible to come up with one score, you should choose the score where value Y (the number of goals Berland misses) is minimum.
Input
The input has five lines.
Each line describes a game as "team1 team2 goals1:goals2" (without the quotes), what means that team team1 played a game with team team2, besides, team1 scored goals1 goals and team2 scored goals2 goals. The names of teams team1 and team2 are non-empty strings, consisting of uppercase English letters, with length of no more than 20 characters; goals1, goals2 are integers from 0 to 9.
The Berland team is called "BERLAND". It is guaranteed that the Berland team and one more team played exactly 2 games and the the other teams played exactly 3 games.
Output
Print the required score in the last game as X:Y, where X is the number of goals Berland scored and Y is the number of goals the opponent scored. If the Berland team does not get the first or the second place in the group, whatever this game's score is, then print on a single line "IMPOSSIBLE" (without the quotes).
Note, that the result score can be very huge, 10:0 for example.
Examples
Input
AERLAND DERLAND 2:1
DERLAND CERLAND 0:3
CERLAND AERLAND 0:1
AERLAND BERLAND 2:0
DERLAND BERLAND 4:0
Output
6:0
Input
AERLAND DERLAND 2:2
DERLAND CERLAND 2:3
CERLAND AERLAND 1:3
AERLAND BERLAND 2:1
DERLAND BERLAND 4:1
Output
IMPOSSIBLE
Note
In the first sample "BERLAND" plays the last game with team "CERLAND". If Berland wins with score 6:0, the results' table looks like that in the end:
1. AERLAND (points: 9, the difference between scored and missed goals: 4, scored goals: 5)
2. BERLAND (points: 3, the difference between scored and missed goals: 0, scored goals: 6)
3. DERLAND (points: 3, the difference between scored and missed goals: 0, scored goals: 5)
4. CERLAND (points: 3, the difference between scored and missed goals: -4, scored goals: 3)
In the second sample teams "AERLAND" and "DERLAND" have already won 7 and 4 points, respectively. The Berland team wins only 3 points, which is not enough to advance to the next championship stage.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, -1, 0, 1};
const int Days[] = {-1, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
inline int read() {
int ans = 0;
bool f = 1;
char ch = getchar();
while (!isdigit(ch)) f ^= ch == '-', ch = getchar();
while (isdigit(ch)) ans = ((ans << 2) + ans << 1) + (ch ^ 48), ch = getchar();
return f ? ans : -ans;
}
map<string, int> tot, jinqiu, shuqiu, cnt;
vector<string> team;
bool cmp(string a, string b) {
if (tot[a] > tot[b]) return 1;
if (tot[a] < tot[b]) return 0;
if (jinqiu[a] - shuqiu[a] > jinqiu[b] - shuqiu[b]) return 1;
if (jinqiu[a] - shuqiu[a] < jinqiu[b] - shuqiu[b]) return 0;
if (jinqiu[a] > jinqiu[b]) return 1;
if (jinqiu[a] < jinqiu[b]) return 0;
return (a < b);
}
int main(int argc, char const *argv[]) {
ios::sync_with_stdio(false);
for (int i = 0; i < 5; i++) {
char a[30], b[30];
int x, y;
scanf("%s %s %d:%d", a, b, &x, &y);
cnt[a]++, cnt[b]++;
if (x > y) tot[a] += 3;
if (x == y) tot[a]++, tot[b]++;
if (x < y) tot[b] += 3;
jinqiu[a] += x;
jinqiu[b] += y;
shuqiu[a] += y;
shuqiu[b] += x;
}
string enemy;
for (map<string, int>::iterator it = cnt.begin(); it != cnt.end(); ++it) {
team.push_back((it->first));
if ((it->second) == 2 && (it->first) != "BERLAND") enemy = (it->first);
}
for (int i = 1; i < 100; i++)
for (int j = 0; j < 100; j++) {
int p = i + j;
jinqiu["BERLAND"] += p;
shuqiu["BERLAND"] += j;
tot["BERLAND"] += 3;
jinqiu[enemy] += j;
shuqiu[enemy] += p;
sort(team.begin(), team.end(), cmp);
if (team[0] == "BERLAND" || team[1] == "BERLAND") {
printf("%d:%d", p, j);
return 0;
}
jinqiu["BERLAND"] -= p;
shuqiu["BERLAND"] -= j;
jinqiu[enemy] -= j;
shuqiu[enemy] -= p;
tot["BERLAND"] -= 3;
}
printf("IMPOSSIBLE");
return 0;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
The Fair Nut is going to travel to the Tree Country, in which there are n cities. Most of the land of this country is covered by forest. Furthermore, the local road system forms a tree (connected graph without cycles). Nut wants to rent a car in the city u and go by a simple path to city v. He hasn't determined the path, so it's time to do it. Note that chosen path can consist of only one vertex.
A filling station is located in every city. Because of strange law, Nut can buy only w_i liters of gasoline in the i-th city. We can assume, that he has infinite money. Each road has a length, and as soon as Nut drives through this road, the amount of gasoline decreases by length. Of course, Nut can't choose a path, which consists of roads, where he runs out of gasoline. He can buy gasoline in every visited city, even in the first and the last.
He also wants to find the maximum amount of gasoline that he can have at the end of the path. Help him: count it.
Input
The first line contains a single integer n (1 β€ n β€ 3 β
10^5) β the number of cities.
The second line contains n integers w_1, w_2, β¦, w_n (0 β€ w_{i} β€ 10^9) β the maximum amounts of liters of gasoline that Nut can buy in cities.
Each of the next n - 1 lines describes road and contains three integers u, v, c (1 β€ u, v β€ n, 1 β€ c β€ 10^9, u β v), where u and v β cities that are connected by this road and c β its length.
It is guaranteed that graph of road connectivity is a tree.
Output
Print one number β the maximum amount of gasoline that he can have at the end of the path.
Examples
Input
3
1 3 3
1 2 2
1 3 2
Output
3
Input
5
6 3 2 5 0
1 2 10
2 3 3
2 4 1
1 5 1
Output
7
Note
The optimal way in the first example is 2 β 1 β 3.
<image>
The optimal way in the second example is 2 β 4.
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n;
int w[300001];
long long f[300001];
int e[300001];
vector<pair<int, int>> g[300001];
set<pair<long long, int>> s[300001];
deque<int> order;
bool done[300001];
void cal(int u) {
if (s[u].empty())
f[u] = 0;
else
f[u] = max(0LL, s[u].rbegin()->first);
f[u] += w[u];
}
void attach(int u, int v) { s[v].insert({f[u] - e[u], u}); }
void detach(int u, int v) { s[v].erase({f[u] - e[u], u}); }
void dfs(int u) {
done[u] = 1;
order.push_back(u);
for (auto v : g[u])
if (!done[v.first]) {
e[v.first] = v.second;
dfs(v.first);
attach(v.first, u);
order.push_back(u);
}
cal(u);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n;
for (int i = 1; i <= n; i++) cin >> w[i];
for (int i = 1, u, v, c; i < n; i++) {
cin >> u >> v >> c;
g[u].push_back({v, c});
g[v].push_back({u, c});
}
dfs(1);
order.pop_front();
long long ans = f[1];
int root = 1;
for (int u : order) {
detach(u, root);
e[root] = e[u];
cal(root);
attach(root, u);
cal(u);
root = u;
ans = max(ans, f[root]);
}
cout << ans << '\n';
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
You are given three sequences: a_1, a_2, β¦, a_n; b_1, b_2, β¦, b_n; c_1, c_2, β¦, c_n.
For each i, a_i β b_i, a_i β c_i, b_i β c_i.
Find a sequence p_1, p_2, β¦, p_n, that satisfy the following conditions:
* p_i β \\{a_i, b_i, c_i\}
* p_i β p_{(i mod n) + 1}.
In other words, for each element, you need to choose one of the three possible values, such that no two adjacent elements (where we consider elements i,i+1 adjacent for i<n and also elements 1 and n) will have equal value.
It can be proved that in the given constraints solution always exists. You don't need to minimize/maximize anything, you need to find any proper sequence.
Input
The first line of input contains one integer t (1 β€ t β€ 100): the number of test cases.
The first line of each test case contains one integer n (3 β€ n β€ 100): the number of elements in the given sequences.
The second line contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 100).
The third line contains n integers b_1, b_2, β¦, b_n (1 β€ b_i β€ 100).
The fourth line contains n integers c_1, c_2, β¦, c_n (1 β€ c_i β€ 100).
It is guaranteed that a_i β b_i, a_i β c_i, b_i β c_i for all i.
Output
For each test case, print n integers: p_1, p_2, β¦, p_n (p_i β \\{a_i, b_i, c_i\}, p_i β p_{i mod n + 1}).
If there are several solutions, you can print any.
Example
Input
5
3
1 1 1
2 2 2
3 3 3
4
1 2 1 2
2 1 2 1
3 4 3 4
7
1 3 3 1 1 1 1
2 4 4 3 2 2 4
4 2 2 2 4 4 2
3
1 2 1
2 3 3
3 1 2
10
1 1 1 2 2 2 3 3 3 1
2 2 2 3 3 3 1 1 1 2
3 3 3 1 1 1 2 2 2 3
Output
1 2 3
1 2 1 2
1 3 4 3 2 4 2
1 3 2
1 2 3 1 2 3 1 2 3 2
Note
In the first test case p = [1, 2, 3].
It is a correct answer, because:
* p_1 = 1 = a_1, p_2 = 2 = b_2, p_3 = 3 = c_3
* p_1 β p_2 , p_2 β p_3 , p_3 β p_1
All possible correct answers to this test case are: [1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1].
In the second test case p = [1, 2, 1, 2].
In this sequence p_1 = a_1, p_2 = a_2, p_3 = a_3, p_4 = a_4. Also we can see, that no two adjacent elements of the sequence are equal.
In the third test case p = [1, 3, 4, 3, 2, 4, 2].
In this sequence p_1 = a_1, p_2 = a_2, p_3 = b_3, p_4 = b_4, p_5 = b_5, p_6 = c_6, p_7 = c_7. Also we can see, that no two adjacent elements of the sequence are equal.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void solve();
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t = 1;
cin >> t;
while (t--) {
solve();
cout << "\n";
}
return 0;
}
void solve() {
unsigned int n, e;
cin >> n;
vector<unsigned long long int> a, b, c;
for (int i = 0; i < n; i++) {
cin >> e;
a.push_back(e);
}
for (int i = 0; i < n; i++) {
cin >> e;
b.push_back(e);
}
for (int i = 0; i < n; i++) {
cin >> e;
c.push_back(e);
}
unsigned long long int prev = a[0];
cout << a[0] << " ";
for (int i = 1; i < n - 1; i++) {
if (a[i] != prev) {
cout << a[i] << " ";
prev = a[i];
} else if (b[i] != prev) {
cout << b[i] << " ";
prev = b[i];
} else {
cout << c[i] << " ";
prev = c[i];
}
}
int i = n - 1;
int prev2 = a[0];
if (a[i] != prev && a[i] != prev2) {
cout << a[i];
} else if (b[i] != prev && b[i] != prev2) {
cout << b[i];
} else {
cout << c[i];
}
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
Two players play a simple game. Each player is provided with a box with balls. First player's box contains exactly n1 balls and second player's box contains exactly n2 balls. In one move first player can take from 1 to k1 balls from his box and throw them away. Similarly, the second player can take from 1 to k2 balls from his box in his move. Players alternate turns and the first player starts the game. The one who can't make a move loses. Your task is to determine who wins if both players play optimally.
Input
The first line contains four integers n1, n2, k1, k2. All numbers in the input are from 1 to 50.
This problem doesn't have subproblems. You will get 3 points for the correct submission.
Output
Output "First" if the first player wins and "Second" otherwise.
Examples
Input
2 2 1 2
Output
Second
Input
2 1 1 1
Output
First
Note
Consider the first sample test. Each player has a box with 2 balls. The first player draws a single ball from his box in one move and the second player can either take 1 or 2 balls from his box in one move. No matter how the first player acts, the second player can always win if he plays wisely.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long int a, b, c, d, e, cnt = 0, snt = 0, f;
string s, n, s1;
vector<int> v;
char u;
int main() {
cin >> a >> b >> c >> d;
a -= 1;
b -= 1;
if (a > b) {
cout << "First";
} else {
cout << "Second";
}
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
Let's consider all integers in the range from 1 to n (inclusive).
Among all pairs of distinct integers in this range, find the maximum possible greatest common divisor of integers in pair. Formally, find the maximum value of gcd(a, b), where 1 β€ a < b β€ n.
The greatest common divisor, gcd(a, b), of two positive integers a and b is the biggest integer that is a divisor of both a and b.
Input
The first line contains a single integer t (1 β€ t β€ 100) β the number of test cases. The description of the test cases follows.
The only line of each test case contains a single integer n (2 β€ n β€ 10^6).
Output
For each test case, output the maximum value of gcd(a, b) among all 1 β€ a < b β€ n.
Example
Input
2
3
5
Output
1
2
Note
In the first test case, gcd(1, 2) = gcd(2, 3) = gcd(1, 3) = 1.
In the second test case, 2 is the maximum possible value, corresponding to gcd(2, 4).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void lc() { cout << endl; }
long long md(long long n) { return n % 1000000007; }
void solve() {
long long n;
cin >> n;
if (n % 2)
cout << (n - 1) / 2;
else
cout << n / 2;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long t = 1;
cin >> t;
while (t--) {
solve();
lc();
}
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
Kevin Sun has just finished competing in Codeforces Round #334! The round was 120 minutes long and featured five problems with maximum point values of 500, 1000, 1500, 2000, and 2500, respectively. Despite the challenging tasks, Kevin was uncowed and bulldozed through all of them, distinguishing himself from the herd as the best cowmputer scientist in all of Bovinia. Kevin knows his submission time for each problem, the number of wrong submissions that he made on each problem, and his total numbers of successful and unsuccessful hacks. Because Codeforces scoring is complicated, Kevin wants you to write a program to compute his final score.
Codeforces scores are computed as follows: If the maximum point value of a problem is x, and Kevin submitted correctly at minute m but made w wrong submissions, then his score on that problem is <image>. His total score is equal to the sum of his scores for each problem. In addition, Kevin's total score gets increased by 100 points for each successful hack, but gets decreased by 50 points for each unsuccessful hack.
All arithmetic operations are performed with absolute precision and no rounding. It is guaranteed that Kevin's final score is an integer.
Input
The first line of the input contains five space-separated integers m1, m2, m3, m4, m5, where mi (0 β€ mi β€ 119) is the time of Kevin's last submission for problem i. His last submission is always correct and gets accepted.
The second line contains five space-separated integers w1, w2, w3, w4, w5, where wi (0 β€ wi β€ 10) is Kevin's number of wrong submissions on problem i.
The last line contains two space-separated integers hs and hu (0 β€ hs, hu β€ 20), denoting the Kevin's numbers of successful and unsuccessful hacks, respectively.
Output
Print a single integer, the value of Kevin's final score.
Examples
Input
20 40 60 80 100
0 1 2 3 4
1 0
Output
4900
Input
119 119 119 119 119
0 0 0 0 0
10 0
Output
4930
Note
In the second sample, Kevin takes 119 minutes on all of the problems. Therefore, he gets <image> of the points on each problem. So his score from solving problems is <image>. Adding in 10Β·100 = 1000 points from hacks, his total score becomes 3930 + 1000 = 4930.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int h[2];
double m[5], w[5], x[5] = {500, 1000, 1500, 2000, 2500}, ans;
int main() {
for (int i = (0); i < (5); ++i) cin >> m[i];
for (int i = (0); i < (5); ++i) cin >> w[i];
cin >> h[0] >> h[1];
for (int i = (0); i < (5); ++i)
ans +=
max(0.3000 * x[i], (1.0000 - m[i] / 250.0000) * x[i] - 50.0000 * w[i]);
printf("%d ", int(ans) + h[0] * 100 - h[1] * 50);
return 0;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
You are given an array a consisting of n integers. You can perform the following operations arbitrary number of times (possibly, zero):
1. Choose a pair of indices (i, j) such that |i-j|=1 (indices i and j are adjacent) and set a_i := a_i + |a_i - a_j|;
2. Choose a pair of indices (i, j) such that |i-j|=1 (indices i and j are adjacent) and set a_i := a_i - |a_i - a_j|.
The value |x| means the absolute value of x. For example, |4| = 4, |-3| = 3.
Your task is to find the minimum number of operations required to obtain the array of equal elements and print the order of operations to do it.
It is guaranteed that you always can obtain the array of equal elements using such operations.
Note that after each operation each element of the current array should not exceed 10^{18} by absolute value.
Input
The first line of the input contains one integer n (1 β€ n β€ 2 β
10^5) β the number of elements in a.
The second line of the input contains n integers a_1, a_2, ..., a_n (0 β€ a_i β€ 2 β
10^5), where a_i is the i-th element of a.
Output
In the first line print one integer k β the minimum number of operations required to obtain the array of equal elements.
In the next k lines print operations itself. The p-th operation should be printed as a triple of integers (t_p, i_p, j_p), where t_p is either 1 or 2 (1 means that you perform the operation of the first type, and 2 means that you perform the operation of the second type), and i_p and j_p are indices of adjacent elements of the array such that 1 β€ i_p, j_p β€ n, |i_p - j_p| = 1. See the examples for better understanding.
Note that after each operation each element of the current array should not exceed 10^{18} by absolute value.
If there are many possible answers, you can print any.
Examples
Input
5
2 4 6 6 6
Output
2
1 2 3
1 1 2
Input
3
2 8 10
Output
2
2 2 1
2 3 2
Input
4
1 1 1 1
Output
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n), cnt(200 * 1000 + 1);
for (int i = 0; i < n; ++i) {
cin >> a[i];
++cnt[a[i]];
}
int val = max_element(cnt.begin(), cnt.end()) - cnt.begin();
int pos = find(a.begin(), a.end(), val) - a.begin();
cout << n - cnt[val] << endl;
int siz = 0;
for (int i = pos - 1; i >= 0; --i) {
cout << 1 + (a[i] > a[i + 1]) << " " << i + 1 << " " << i + 2 << " "
<< endl;
a[i] = a[i + 1];
++siz;
}
for (int i = 0; i < n - 1; ++i) {
if (a[i + 1] != val) {
assert(a[i] == val);
cout << 1 + (a[i + 1] > a[i]) << " " << i + 2 << " " << i + 1 << " "
<< endl;
a[i + 1] = a[i];
++siz;
}
}
assert(siz == n - cnt[val]);
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
Natsume loves big cats. One day, Natsume was invited by the stray cats she was always close to to go to the mysterious bookstore where the cats were open. When I heard that the bookstore sells books with many pictures of cats, Natsume decided to follow her happily.
I didn't know Natsume, but the bookstore that was taken by the cats was a famous store with chain stores nationwide. The store has a solid manual for the clerk, and the behavior of the clerk is unified in every store. The following is an excerpt from the manual.
1. When a customer enters the store through a door within a 10-Euclidean distance from the clerk, he must say "Welcome Hello" in a loud voice for X seconds.
2. When the clerk who heard another clerk within the Euclidean distance of 50 saying "Welcome Hello", the clerk said "Welcome Hello" at the end of the utterance of "Welcome Hello" in a loud voice over X seconds. Must. However, a clerk who has completed uttering another "Welcome Hello" within the past Y seconds from the start of uttering this repeat must not repeat it.
Given the X, Y, customer location, and clerk placement, calculate how many seconds it will take for the store to be quiet after the customer enters. If the repeat does not stop, print "You're always welcome!".
Notes on Submission
Multiple datasets are given in the above format. The first line of input data gives the number of datasets. Create a program that outputs the output for each data set in order in the above format.
Input
The number N of the clerk and the X and Y written in the manual are given on the first line of the input, separated by one space character. The second line is the position where Natsume enters the store, and the following N lines are the coordinates representing the positions of N clerk. Each position is given by separating the x and y coordinates with a single space character, and each number is given as an integer between 0 and 1000. Also, 1 <= N <= 1000, 1 <= X, Y <= 100 is satisfied.
Output
If the repeat does not stop, output the time from when the customer enters the store until it becomes quiet, and if it does not stop, output "You're always welcome!" On one line.
Example
Input
4
3 3 5
0 0
10 0
40 40
40 90
4 5 10
100 100
50 100
50 150
100 50
100 150
4 60 10
100 100
90 100
110 100
100 90
100 110
4 60 10
100 100
80 100
110 100
100 80
100 110
Output
9
0
60
You're always welcome!
### Response
```cpp
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <iostream>
#include <math.h>
#include <assert.h>
#include <vector>
#include <queue>
#include <string>
#include <map>
#include <set>
using namespace std;
typedef long long ll;
typedef unsigned int uint;
typedef unsigned long long ull;
static const double EPS = 1e-9;
static const double PI = acos(-1.0);
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define FOR(i, s, n) for (int i = (s); i < (int)(n); i++)
#define FOREQ(i, s, n) for (int i = (s); i <= (int)(n); i++)
#define FORIT(it, c) for (__typeof((c).begin())it = (c).begin(); it != (c).end(); it++)
#define MEMSET(v, h) memset((v), h, sizeof(v))
typedef vector<int> Edges;
typedef vector<Edges> Graph;
inline int square(int x) { return x * x; }
int n, t1, t2;
vector<int> state;
int x[1010];
int y[1010];
Graph g;
vector<int> cand;
int main() {
int test;
scanf("%d", &test);
while (test--) {
int sx, sy;
scanf("%d %d %d %d %d", &n, &t1, &t2, &sx, &sy);
t2++;
g = Graph(n);
state = vector<int>(n, 0);
REP(i, n) {
scanf("%d %d", &x[i], &y[i]);
}
REP(i, n) {
if (square(x[i] - sx) + square(y[i] - sy) <= 100) {
//cout << i << endl;
state[i] = t1;
}
REP(j, i) {
if (square(x[i] - x[j]) + square(y[i] - y[j]) <= 2500) {
//cout << i << " " << j << endl;
g[i].push_back(j);
g[j].push_back(i);
}
}
}
ll ans = 0;
set<vector<int> > open;
while (true) {
if (open.count(state)) {
puts("You're always welcome!");
goto next;
}
open.insert(state);
int nt = 1 << 20;
REP(i, n) {
if (state[i] > 0) { nt = min(nt, state[i]); }
}
if (nt == (1 << 20)) { break; }
queue<int> que;
ans += nt;
REP(i, n) {
int l = nt;
if (state[i] > 0) {
if (state[i] == nt) { que.push(i); }
int t = min(state[i], l);
state[i] -= t;
l -= t;
if (state[i] == 0) { state[i] = -t2; }
}
if (state[i] < 0 && l > 0) {
state[i] += l;
state[i] = min(state[i], 0);
}
}
while (!que.empty()) {
int from = que.front();
que.pop();
FORIT(it, g[from]) {
int to = *it;
if (state[to] == 0) { state[to] = t1; }
}
}
}
printf("%lld\n", ans);
next:;
}
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
You are playing a video game and you have just reached the bonus level, where the only possible goal is to score as many points as possible. Being a perfectionist, you've decided that you won't leave this level until you've gained the maximum possible number of points there.
The bonus level consists of n small platforms placed in a line and numbered from 1 to n from left to right and (n - 1) bridges connecting adjacent platforms. The bridges between the platforms are very fragile, and for each bridge the number of times one can pass this bridge from one of its ends to the other before it collapses forever is known in advance.
The player's actions are as follows. First, he selects one of the platforms to be the starting position for his hero. After that the player can freely move the hero across the platforms moving by the undestroyed bridges. As soon as the hero finds himself on a platform with no undestroyed bridge attached to it, the level is automatically ended. The number of points scored by the player at the end of the level is calculated as the number of transitions made by the hero between the platforms. Note that if the hero started moving by a certain bridge, he has to continue moving in the same direction until he is on a platform.
Find how many points you need to score to be sure that nobody will beat your record, and move to the next level with a quiet heart.
Input
The first line contains a single integer n (2 β€ n β€ 105) β the number of platforms on the bonus level. The second line contains (n - 1) integers ai (1 β€ ai β€ 109, 1 β€ i < n) β the number of transitions from one end to the other that the bridge between platforms i and i + 1 can bear.
Output
Print a single integer β the maximum number of points a player can get on the bonus level.
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
5
2 1 2 1
Output
5
Note
One possibility of getting 5 points in the sample is starting from platform 3 and consequently moving to platforms 4, 3, 2, 1 and 2. After that the only undestroyed bridge is the bridge between platforms 4 and 5, but this bridge is too far from platform 2 where the hero is located now.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
const long long INF = 1E18;
long long dpL[N][2], dpR[N][2];
int seg[N];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &seg[i]);
memset(dpL, 0, sizeof dpL);
memset(dpR, 0, sizeof dpR);
for (int i = 2; i <= n; i++) {
if (seg[i - 1] > 1)
dpL[i][1] =
dpL[i - 1][1] + ((seg[i - 1] & 1) ? seg[i - 1] - 1 : seg[i - 1]);
else
dpL[i][1] = 0;
dpL[i][0] = max(dpL[i - 1][0], dpL[i - 1][1]) +
((seg[i - 1] & 1) ? seg[i - 1] : seg[i - 1] - 1);
dpL[i][0] = max(dpL[i][0], dpL[i][1]);
}
for (int i = n - 1; i >= 0; i--) {
if (seg[i] > 1)
dpR[i][1] = dpR[i + 1][1] + ((seg[i] & 1) ? seg[i] - 1 : seg[i]);
else
dpR[i][1] = 0;
dpR[i][0] = max(dpR[i + 1][0], dpR[i + 1][1]) +
((seg[i] & 1) ? seg[i] : seg[i] - 1);
dpR[i][0] = max(dpR[i][0], dpR[i][1]);
}
long long maxAns = -1;
for (int i = 1; i <= n; i++) {
long long ans = max(dpL[i][1] + dpR[i][0], dpL[i][0] + dpR[i][1]);
maxAns = max(ans, maxAns);
}
cout << maxAns << endl;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
Berland has managed to repel the flatlanders' attack and is now starting the counter attack.
Flatland has n cities, numbered from 1 to n, and some pairs of them are connected by bidirectional roads. The Flatlandian maps show roads between cities if and only if there is in fact no road between this pair of cities (we do not know whether is it a clever spy-proof strategy or just saving ink). In other words, if two cities are connected by a road on a flatland map, then there is in fact no road between them. The opposite situation is also true: if two cities are not connected by a road on a flatland map, then in fact, there is a road between them.
The berlanders got hold of a flatland map. Now Vasya the Corporal is commissioned by General Touristov to find all such groups of flatland cities, that in each group of cities you can get from any city to any other one, moving along the actual roads. Also the cities from different groups are unreachable from each other, moving along the actual roads. Indeed, destroying such groups one by one is much easier than surrounding all Flatland at once!
Help the corporal complete this task and finally become a sergeant! Don't forget that a flatland map shows a road between cities if and only if there is in fact no road between them.
Input
The first line contains two space-separated integers n and m (1 β€ n β€ 5Β·105, 0 β€ m β€ 106) β the number of cities and the number of roads marked on the flatland map, correspondingly.
Next m lines contain descriptions of the cities on the map. The i-th line contains two integers ai and bi (1 β€ ai, bi β€ n, ai β bi) β the numbers of cities that are connected by the i-th road on the flatland map.
It is guaranteed that each pair of cities occurs in the input no more than once.
Output
On the first line print number k β the number of groups of cities in Flatland, such that in each group you can get from any city to any other one by flatland roads. At the same time, the cities from different groups should be unreachable by flatland roads.
On each of the following k lines first print ti (1 β€ ti β€ n) β the number of vertexes in the i-th group. Then print space-separated numbers of cities in the i-th group.
The order of printing groups and the order of printing numbers in the groups does not matter. The total sum ti for all k groups must equal n.
Examples
Input
4 4
1 2
1 3
4 2
4 3
Output
2
2 1 4
2 2 3
Input
3 1
1 2
Output
1
3 1 2 3
Note
In the first sample there are roads only between pairs of cities 1-4 and 2-3.
In the second sample there is no road between cities 1 and 2, but still you can get from one city to the other one through city number 3.
### Response
```cpp
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
const int sz = 500500;
int B[sz], dp[sz], gr, n, m;
vector<int> A[sz];
vector<int> res[sz];
queue<pair<int, int> > Q;
int next(int v) {
if (!B[v])
return v;
else
return dp[v] = next(dp[v]);
}
void bfs(int v) {
pair<int, int> cur;
int l, r, nv;
gr++;
Q.push(make_pair(v, v));
while (!Q.empty()) {
cur = Q.front();
Q.pop();
l = cur.first;
r = cur.second;
nv = next(l);
while (nv <= r) {
B[nv] = 1;
res[gr].push_back(nv);
dp[nv] = next(nv + 1);
if (A[nv].size() > 0) {
if (A[nv][0] > 1) Q.push(make_pair(1, A[nv][0] - 1));
for (int j = 1; j < A[nv].size(); j++)
if (A[nv][j] > (A[nv][j - 1] + 1)) {
Q.push(make_pair(A[nv][j - 1] + 1, A[nv][j] - 1));
}
if (n > A[nv].back()) {
Q.push(make_pair(A[nv].back() + 1, n));
}
} else {
Q.push(make_pair(1, n));
}
nv = next(nv);
}
}
}
int main() {
int a, b;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &a, &b);
A[a].push_back(b);
A[b].push_back(a);
}
for (int i = 1; i <= n; i++) {
sort(A[i].begin(), A[i].end());
dp[i] = i;
}
for (int i = 1; i <= n; i++)
if (!B[i]) bfs(i);
printf("%d\n", gr);
for (int i = 1; i <= gr; i++) {
printf("%d", (int)res[i].size());
for (int j = 0; j < res[i].size(); j++) printf(" %d", res[i][j]);
printf("\n");
}
return 0;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
You are given a sequence of n digits d_1d_2 ... d_{n}. You need to paint all the digits in two colors so that:
* each digit is painted either in the color 1 or in the color 2;
* if you write in a row from left to right all the digits painted in the color 1, and then after them all the digits painted in the color 2, then the resulting sequence of n digits will be non-decreasing (that is, each next digit will be greater than or equal to the previous digit).
For example, for the sequence d=914 the only valid coloring is 211 (paint in the color 1 two last digits, paint in the color 2 the first digit). But 122 is not a valid coloring (9 concatenated with 14 is not a non-decreasing sequence).
It is allowed that either of the two colors is not used at all. Digits painted in the same color are not required to have consecutive positions.
Find any of the valid ways to paint the given sequence of digits or determine that it is impossible to do.
Input
The first line contains a single integer t (1 β€ t β€ 10000) β the number of test cases in the input.
The first line of each test case contains an integer n (1 β€ n β€ 2β
10^5) β the length of a given sequence of digits.
The next line contains a sequence of n digits d_1d_2 ... d_{n} (0 β€ d_i β€ 9). The digits are written in a row without spaces or any other separators. The sequence can start with 0.
It is guaranteed that the sum of the values ββof n for all test cases in the input does not exceed 2β
10^5.
Output
Print t lines β the answers to each of the test cases in the input.
If there is a solution for a test case, the corresponding output line should contain any of the valid colorings written as a string of n digits t_1t_2 ... t_n (1 β€ t_i β€ 2), where t_i is the color the i-th digit is painted in. If there are several feasible solutions, print any of them.
If there is no solution, then the corresponding output line should contain a single character '-' (the minus sign).
Example
Input
5
12
040425524644
1
0
9
123456789
2
98
3
987
Output
121212211211
1
222222222
21
-
Note
In the first test case, d=040425524644. The output t=121212211211 is correct because 0022444 (painted in 1) concatenated with 44556 (painted in 2) is 002244444556 which is a sorted sequence of n given digits.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
char a[200010];
int b[200010];
struct point {
int x;
int y;
} v[200010];
bool cmp(point a, point b) {
if (a.x == b.x) return a.y < b.y;
return a.x < b.x;
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
memset(b, 0, sizeof(b));
int n;
scanf("%d", &n);
scanf("%s", a);
for (int i = 0; i < n; i++) {
v[i].x = a[i] - '0';
v[i].y = i;
}
sort(v, v + n, cmp);
b[v[0].y] = 1;
int m = n;
int h = 100;
int r = 0;
int e = -1;
int w = v[0].y;
int flag = 0;
for (int i = 1; i < n; i++) {
if (v[i].x > h && v[i].y > e) {
m = i;
e = v[i].y;
b[e] = 2;
break;
}
if (v[i].y > w) {
w = v[i].y;
b[v[i].y] = 1;
} else {
if (r == 0) {
h = v[i].x;
r = 1;
}
if (e < v[i].y) {
e = v[i].y;
b[v[i].y] = 2;
m = i;
} else {
flag = 1;
break;
}
}
}
int u = v[m].x;
for (int i = m + 1; i < n; i++) {
if (v[i].y > e) {
e = v[i].y;
b[v[i].y] = 2;
} else {
flag = 1;
break;
}
}
if (flag == 0) {
for (int i = 0; i < n; i++) {
printf("%d", b[i]);
}
printf("\n");
} else
printf("-\n");
}
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
Ringo got interested in modern art. He decided to draw a big picture on the board with N+2 rows and M+2 columns of squares constructed in the venue of CODE FESTIVAL 2017, using some people.
The square at the (i+1)-th row and (j+1)-th column in the board is represented by the pair of integers (i,j). That is, the top-left square is (0,0), and the bottom-right square is (N+1,M+1). Initially, the squares (x,y) satisfying 1 \leq x \leq N and 1 \leq y \leq M are painted white, and the other (outermost) squares are painted black.
Ringo arranged people at some of the outermost squares, facing inward. More specifically, the arrangement of people is represented by four strings A, B, C and D, as follows:
* For each row except the top and bottom, if the i-th character (1 \leq i \leq N) in A is `1`, place a person facing right at the square (i,0); otherwise, do nothing.
* For each row except the top and bottom, if the i-th character (1 \leq i \leq N) in B is `1`, place a person facing left at the square (i,M+1); otherwise, do nothing.
* For each column except the leftmost and rightmost, if the i-th character (1 \leq i \leq M) in C is `1`, place a person facing down at the square (0,i); otherwise, do nothing.
* For each column except the leftmost and rightmost, if the i-th character (1 \leq i \leq M) in D is `1`, place a person facing up at the square (N+1,i); otherwise, do nothing.
Each person has a sufficient amount of non-white paint. No two people have paint of the same color.
<image>
An example of an arrangement of people (For convenience, black squares are displayed in gray)
Ringo repeats the following sequence of operations until all people are dismissed from the venue.
* Select a person who is still in the venue.
* The selected person repeats the following action while the square in front of him/her is white: move one square forward, and paint the square he/she enters with his/her paint. When the square in front of him/her is not white, he/she stops doing the action.
* The person is now dismissed from the venue.
<image>
An example of a way the board is painted
How many different states of the board can Ringo obtain at the end of the process? Find the count modulo 998244353.
Two states of the board are considered different when there is a square painted in different colors.
Constraints
* 1 \leq N,M \leq 10^5
* |A|=|B|=N
* |C|=|D|=M
* A, B, C and D consist of `0` and `1`.
Input
Input is given from Standard Input in the following format:
N M
A
B
C
D
Output
Print the number of the different states of the board Ringo can obtain at the end of the process, modulo 998244353.
Examples
Input
2 2
10
01
10
01
Output
6
Input
2 2
11
11
11
11
Output
32
Input
3 4
111
111
1111
1111
Output
1276
Input
17 21
11001010101011101
11001010011010111
111010101110101111100
011010110110101000111
Output
548356548
Input
3 4
000
101
1111
0010
Output
21
Input
9 13
111100001
010101011
0000000000000
1010111111101
Output
177856
Input
23 30
01010010101010010001110
11010100100100101010101
000101001001010010101010101101
101001000100101001010010101000
Output
734524988
### Response
```cpp
#include <iostream>
#include <string>
using namespace std;
long long fact[300009], factinv[300009], mod = 998244353;
long long modpow(long long a, long long b, long long m) {
long long p = 1, q = a;
for (int i = 0; i < 32; i++) {
if ((b / (1LL << i)) % 2 == 1) { p *= q; p %= m; }
q *= q; q %= m;
}
return p;
}
long long Div(long long a, long long b, long long m) {
return (a * modpow(b, m - 2, m)) % m;
}
void init() {
fact[0] = 1; for (int i = 1; i <= 300000; i++) fact[i] = (fact[i - 1] * i) % mod;
for (int i = 0; i <= 300000; i++) factinv[i] = Div(1, fact[i], mod);
}
long long ncr(long long n, long long r) {
if (r < 0 || n < r) return 0;
return (fact[n] * factinv[r] % mod) * factinv[n - r] % mod;
}
long long N, M, cnt, p1, p2, L1[100009], L2[100009]; string A, B, C, D;
void dels() {
cnt = 0; p1 = 0; p2 = 0;
for (int i = 0; i < 100009; i++) { L1[i] = 0; L2[i] = 0; }
}
long long solve() {
dels();
for (int i = 0; i < N; i++) { if (A[i] == '1' || B[i] == '1') cnt++; }
for (int i = 0; i < M; i++) { if (C[i] == '1') p1++; if (D[i] == '1') p2++; }
int v = 0; L1[0] = 1;
for (int i = 0; i < N; i++) {
if (A[i] == '1') v++;
if (B[i] == '1') v++;
L1[i + 1] = ncr(v + p1 - 1, p1 - 1);
bool flag = false; if (v == 0) flag = true;
if (flag == true && p1 == 0) L1[i + 1] = 1;
}
v = 0; L2[N - 1] = 1;
for (int i = N - 1; i >= 1; i--) {
if (A[i] == '1') v++;
if (B[i] == '1') v++;
L2[i - 1] = ncr(v + p2 - 1, p2 - 1);
bool flag = false; if (v == 0) flag = true;
if (flag == true && p2 == 0) L2[i - 1] = 1;
}
long long ret = 0, ans = 0;
for (int i = N - 1; i >= 0; i--) {
if (A[i] == '1' || B[i] == '1') ret += L2[i];
ret %= mod;
if (A[i] == '1' && B[i] == '1') ans += L1[i] * ret;
if (A[i] == '1' || B[i] == '1') ans += L1[i] * ret;
ans %= mod;
if (A[i] == '1' && B[i] == '1') ret *= 2;
}
return ans;
}
int main() {
init();
cin >> N >> M >> A >> B >> C >> D;
int rem = 0;
for (int i = 0; i < N; i++) { rem += (A[i] - '0'); rem += (B[i] - '0'); }
for (int i = 0; i < M; i++) { rem += (C[i] - '0'); rem += (D[i] - '0'); }
if (rem == 0) {
cout << "1" << endl;
return 0;
}
long long c1 = solve(); swap(N, M); swap(A, C); swap(B, D);
long long c2 = solve(); swap(N, M); swap(A, C); swap(B, D);
cout << (c1 + c2) % mod << endl;
return 0;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
A star is a figure of the following type: an asterisk character '*' in the center of the figure and four rays (to the left, right, top, bottom) of the same positive length. The size of a star is the length of its rays. The size of a star must be a positive number (i.e. rays of length 0 are not allowed).
Let's consider empty cells are denoted by '.', then the following figures are stars:
<image> The leftmost figure is a star of size 1, the middle figure is a star of size 2 and the rightmost figure is a star of size 3.
You are given a rectangular grid of size n Γ m consisting only of asterisks '*' and periods (dots) '.'. Rows are numbered from 1 to n, columns are numbered from 1 to m. Your task is to draw this grid using any number of stars or find out that it is impossible. Stars can intersect, overlap or even coincide with each other. The number of stars in the output can't exceed n β
m. Each star should be completely inside the grid. You can use stars of same and arbitrary sizes.
In this problem, you do not need to minimize the number of stars. Just find any way to draw the given grid with at most n β
m stars.
Input
The first line of the input contains two integers n and m (3 β€ n, m β€ 100) β the sizes of the given grid.
The next n lines contains m characters each, the i-th line describes the i-th row of the grid. It is guaranteed that grid consists of characters '*' and '.' only.
Output
If it is impossible to draw the given grid using stars only, print "-1".
Otherwise in the first line print one integer k (0 β€ k β€ n β
m) β the number of stars needed to draw the given grid. The next k lines should contain three integers each β x_j, y_j and s_j, where x_j is the row index of the central star character, y_j is the column index of the central star character and s_j is the size of the star. Each star should be completely inside the grid.
Examples
Input
6 8
....*...
...**...
..*****.
...**...
....*...
........
Output
3
3 4 1
3 5 2
3 5 1
Input
5 5
.*...
****.
.****
..**.
.....
Output
3
2 2 1
3 3 1
3 4 1
Input
5 5
.*...
***..
.*...
.*...
.....
Output
-1
Input
3 3
*.*
.*.
*.*
Output
-1
Note
In the first example the output
2
3 4 1
3 5 2
is also correct.
### Response
```cpp
#include <bits/stdc++.h>
namespace chtholly {
inline int read() {
int x = 0, f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar()) f ^= c == '-';
for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + (c ^ '0');
return f ? x : -x;
}
template <typename mitsuha>
inline bool read(mitsuha &x) {
x = 0;
int f = 1;
char c = getchar();
for (; !isdigit(c) && ~c; c = getchar()) f ^= c == '-';
if (!~c) return 0;
for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + (c ^ '0');
return x = f ? x : -x, 1;
}
template <typename mitsuha>
inline int write(mitsuha x) {
if (!x) return 0 & putchar(48);
if (x < 0) x = -x, putchar('-');
int bit[20], i, p = 0;
for (; x; x /= 10) bit[++p] = x % 10;
for (i = p; i; --i) putchar(bit[i] + 48);
return 0;
}
inline char fuhao() {
char c = getchar();
for (; isspace(c); c = getchar())
;
return c;
}
} // namespace chtholly
using namespace chtholly;
using namespace std;
struct llx {
int x, y, d;
};
vector<llx> ans;
int mk[1010][1010], n = read(), m = read();
char c[1010][1010];
bool judge(int i, int j, int k) {
return i + k <= n && i - k > 0 && j + k <= m && j - k > 0 &&
c[i + k][j] == '*' && c[i - k][j] == '*' && c[i][j + k] == '*' &&
c[i][j - k] == '*';
}
int main() {
int i, j, k;
for (i = 1; i <= n; ++i) scanf("%s", c[i] + 1);
for (i = 1; i <= n; ++i) {
for (j = 1; j <= m; ++j) {
if (c[i][j] == '*') {
for (k = 1; k < n; ++k) {
if (judge(i, j, k)) {
mk[i][j] = mk[i + k][j] = mk[i - k][j] = mk[i][j + k] =
mk[i][j - k] = 1;
} else {
if (k > 1) ans.push_back(llx{i, j, k - 1});
break;
}
}
}
}
}
for (i = 1; i <= n; ++i) {
for (j = 1; j <= m; ++j) {
if (c[i][j] == '*' && !mk[i][j]) return puts("-1"), 0;
}
}
cout << ans.size() << endl;
for (llx zxy : ans) printf("%d %d %d\n", zxy.x, zxy.y, zxy.d);
}
``` |
### Prompt
Generate a cpp solution to the following problem:
Snuke has N integers: 1,2,\ldots,N. He will choose K of them and give those to Takahashi.
How many ways are there to choose K consecutive integers?
Constraints
* All values in input are integers.
* 1 \leq K \leq N \leq 50
Input
Input is given from Standard Input in the following format:
N K
Output
Print the answer.
Examples
Input
3 2
Output
2
Input
13 3
Output
11
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int H,N;
cin >>H>>N;
cout << H-N+1 << endl;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
In the Land of Fire there are n villages and n-1 bidirectional road, and there is a path between any pair of villages by roads. There are only two types of roads: stone ones and sand ones. Since the Land of Fire is constantly renovating, every morning workers choose a single road and flip its type (so it becomes a stone road if it was a sand road and vice versa). Also everyone here loves ramen, that's why every morning a ramen pavilion is set in the middle of every stone road, and at the end of each day all the pavilions are removed.
For each of the following m days, after another road is flipped, Naruto and Jiraiya choose a simple path β that is, a route which starts in a village and ends in a (possibly, the same) village, and doesn't contain any road twice. Since Naruto and Jiraiya also love ramen very much, they buy a single cup of ramen on each stone road and one of them eats it. Since they don't want to offend each other, they only choose routes where they can eat equal number of ramen cups. Since they both like traveling, they choose any longest possible path. After every renovation find the maximal possible length of a path (that is, the number of roads in it) they can follow.
Input
The first line contains the only positive integer n (2 β€ n β€ 500 000) standing for the number of villages in the Land of Fire.
Each of the following (n-1) lines contains a description of another road, represented as three positive integers u, v and t (1 β€ u, v β€ n, t β \{0,1\}). The first two numbers denote the villages connected by the road, and the third denotes the initial type of the road: 0 for the sand one and 1 for the stone one. Roads are numbered from 1 to (n-1) in the order from the input.
The following line contains a positive integer m (1 β€ m β€ 500 000) standing for the number of days Naruto and Jiraiya travel for.
Each of the following m lines contains the single integer id (1 β€ id β€ n-1) standing for the index of the road whose type is flipped on the morning of corresponding day.
It is guaranteed that there is a road path between any pair of villages.
Output
Output m lines. In the i-th of them print the only integer denoting the maximal possible length of any valid path on the i-th day.
Example
Input
5
1 2 0
1 3 0
3 5 0
3 4 0
5
3
4
1
3
4
Output
3
2
3
3
2
Note
After the renovation of the 3-rd road the longest path consists of the roads 1, 2 and 4.
After the renovation of the 4-th road one of the longest paths consists of the roads 1 and 2.
After the renovation of the 1-st road one of the longest paths consists of the roads 1, 2 and 3.
After the renovation of the 3-rd road the longest path consists of the roads 1, 2 and 4.
After the renovation of the 4-rd road one of the longest paths consists of the roads 2 and 4.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
auto seed = chrono::high_resolution_clock::now().time_since_epoch().count();
mt19937 mt(seed);
struct edge {
int to, w;
edge() {}
edge(int to, int w) : to(to), w(w) {}
};
const int MAXN = 500000;
int pp, cur, tmp, vv, ll, rr;
int used[MAXN], roots[2];
vector<vector<int> > d(MAXN, vector<int>(2)), cnt(MAXN, vector<int>(2)),
a(2 * MAXN, vector<int>(2));
vector<vector<vector<int> > > place(MAXN, vector<vector<int> >(2));
vector<vector<edge> > g(MAXN);
void dfs(int v, int x, short p) {
used[v] = 1;
if (p) {
a[pp][x] = v;
cnt[v][x] = cur;
place[v][x].push_back(pp);
pp++;
}
for (auto &e : g[v]) {
if (!used[e.to]) {
d[e.to][x] = d[v][x] + 1;
if (e.w == 1) cur ^= 1;
dfs(e.to, x, p);
if (e.w == 1) cur ^= 1;
}
}
if (p) {
a[pp][x] = v;
cnt[v][x] = cur;
place[v][x].push_back(pp);
pp++;
}
}
struct node {
short swp;
int ans[2];
node() {
swp = 0;
ans[0] = 0;
ans[1] = 0;
}
};
struct tree {
vector<node> t;
tree(short x, int n) {
t.resize(4 * n);
build(0, 0, n, x);
}
void pull() {
t[vv].ans[0] = max(t[vv + vv + 1].ans[0], t[vv + vv + 2].ans[0]);
t[vv].ans[1] = max(t[vv + vv + 1].ans[1], t[vv + vv + 2].ans[1]);
}
void push(int x) {
if (!t[vv].swp) return;
t[vv].swp = 0;
tmp = t[vv].ans[0];
t[vv].ans[0] = t[vv].ans[1];
t[vv].ans[1] = tmp;
if (x == 1) return;
t[vv + vv + 1].swp ^= 1;
t[vv + vv + 2].swp ^= 1;
}
void build(int bv, int bl, int br, short x) {
if (br - bl == 1) {
t[bv].ans[cnt[a[bl][x]][x]] = d[a[bl][x]][x];
return;
}
int m = (bl + br) >> 1;
build(bv + bv + 1, bl, m, x);
build(bv + bv + 2, m, br, x);
vv = bv;
pull();
}
void update(int vl, int vr) {
push(vr - vl);
if (rr <= vl || vr <= ll) return;
if (ll <= vl && vr <= rr) {
t[vv].swp = 1;
push(vr - vl);
return;
}
tmp = (vl + vr) >> 1;
vv = vv + vv + 1;
update(vl, tmp);
tmp = (vl + vr) >> 1;
vv++;
update(tmp, vr);
vv = vv / 2 - 1;
pull();
}
};
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m, i, j;
cin >> n;
vector<pair<int, int> > e(n);
for (i = 1; i < n; i++) {
int v, u, w;
cin >> v >> u >> w;
g[v - 1].emplace_back(u - 1, w);
g[u - 1].emplace_back(v - 1, w);
e[i] = {v - 1, u - 1};
}
cin >> m;
for (i = 0; i < n; i++) used[i] = 0;
roots[0] = 0;
roots[1] = 0;
for (i = 0; i < 2; i++) {
d[roots[0]][0] = 0;
dfs(roots[0], 0, 0);
for (j = 0; j < n; j++) {
if (d[roots[i]][0] < d[j][0]) roots[i] = j;
used[j] = 0;
}
}
for (i = 0; i < 2; i++) {
pp = 0;
cur = 0;
d[roots[i]][i] = 0;
dfs(roots[i], i, 1);
for (j = 0; j < n; j++) used[j] = 0;
}
vector<tree> t = {tree(0, 2 * n), tree(1, 2 * n)};
for (i = 0; i < m; i++) {
int x, ans = 0;
cin >> x;
for (j = 0; j < 2; j++) {
int v = e[x].first;
if (d[e[x].first][j] < d[e[x].second][j]) v = e[x].second;
vv = 0;
ll = place[v][j][0];
rr = place[v][j][1] + 1;
t[j].update(0, 2 * n);
ans = max(ans, t[j].t[0].ans[0]);
}
cout << ans << "\n";
}
return 0;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
Valery is very interested in magic. Magic attracts him so much that he sees it everywhere. He explains any strange and weird phenomenon through intervention of supernatural forces. But who would have thought that even in a regular array of numbers Valera manages to see something beautiful and magical.
Valera absolutely accidentally got a piece of ancient parchment on which an array of numbers was written. He immediately thought that the numbers in this array were not random. As a result of extensive research Valera worked out a wonderful property that a magical array should have: an array is defined as magic if its minimum and maximum coincide.
He decided to share this outstanding discovery with you, but he asks you for help in return. Despite the tremendous intelligence and wit, Valera counts very badly and so you will have to complete his work. All you have to do is count the number of magical subarrays of the original array of numbers, written on the parchment. Subarray is defined as non-empty sequence of consecutive elements.
Input
The first line of the input data contains an integer n (1 β€ n β€ 105). The second line contains an array of original integers a1, a2, ..., an ( - 109 β€ ai β€ 109).
Output
Print on the single line the answer to the problem: the amount of subarrays, which are magical.
Please do not use the %lld specificator to read or write 64-bit numbers in C++. It is recommended to use cin, cout streams (you can also use the %I64d specificator).
Examples
Input
4
2 1 1 4
Output
5
Input
5
-2 -2 -2 0 1
Output
8
Note
Notes to sample tests:
Magical subarrays are shown with pairs of indices [a;b] of the beginning and the end.
In the first sample: [1;1], [2;2], [3;3], [4;4], [2;3].
In the second sample: [1;1], [2;2], [3;3], [4;4], [5;5], [1;2], [2;3], [1;3].
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long a[n];
long long count = 1;
long long ans = 0;
long long flag = 0;
for (long long i = 0; i < n; i++) cin >> a[i];
for (long long i = 1; i < n; i++) {
if (a[i] == a[i - 1]) {
count += 1;
flag = 1;
} else {
ans += (count * (count - 1)) / 2;
flag = 0;
count = 1;
}
}
if (flag == 1) ans += (count * (count - 1)) / 2;
cout << ans + n << "\n";
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
You are given a long decimal number a consisting of n digits from 1 to 9. You also have a function f that maps every digit from 1 to 9 to some (possibly the same) digit from 1 to 9.
You can perform the following operation no more than once: choose a non-empty contiguous subsegment of digits in a, and replace each digit x from this segment with f(x). For example, if a = 1337, f(1) = 1, f(3) = 5, f(7) = 3, and you choose the segment consisting of three rightmost digits, you get 1553 as the result.
What is the maximum possible number you can obtain applying this operation no more than once?
Input
The first line contains one integer n (1 β€ n β€ 2 β
10^5) β the number of digits in a.
The second line contains a string of n characters, denoting the number a. Each character is a decimal digit from 1 to 9.
The third line contains exactly 9 integers f(1), f(2), ..., f(9) (1 β€ f(i) β€ 9).
Output
Print the maximum number you can get after applying the operation described in the statement no more than once.
Examples
Input
4
1337
1 2 5 4 6 6 3 1 9
Output
1557
Input
5
11111
9 8 7 6 5 4 3 2 1
Output
99999
Input
2
33
1 1 1 1 1 1 1 1 1
Output
33
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAX = 201000;
const int MAX_1 = 500000;
const int INF = 0xfffffff;
const double EPS = 0.0000001;
const int MOD = 10000007;
int T, N, M;
char a[15];
char c[MAX];
int main() {
std::ios::sync_with_stdio(false);
cin >> N;
cin >> c;
a[0] = '0';
for (int i = 1; i < 10; i++) {
cin >> a[i];
}
for (int i = 0; i < N; i++) {
if (a[c[i] - 48] > c[i]) {
for (int j = i; j < N; j++) {
if (a[c[j] - 48] >= c[j]) {
c[j] = a[c[j] - 48];
} else
break;
}
break;
}
}
cout << c << "\n";
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
A flow network is a directed graph which has a $source$ and a $sink$. In a flow network, each edge $(u, v)$ has a capacity $c(u, v)$. Each edge receives a flow, but the amount of flow on the edge can not exceed the corresponding capacity. Find the maximum flow from the $source$ to the $sink$.
Constraints
* $2 \leq |V| \leq 100$
* $1 \leq |E| \leq 1000$
* $0 \leq c_i \leq 10000$
Input
A flow network is given in the following format.
$|V|\;|E|$
$u_0\;v_0\;c_0$
$u_1\;v_1\;c_1$
:
$u_{|E|-1}\;v_{|E|-1}\;c_{|E|-1}$
$|V|$, $|E|$ is the number of vertices and edges of the flow network respectively. The vertices in $G$ are named with the numbers 0, 1,..., $|V|-1$. The source is 0 and the sink is $|V|-1$.
$u_i$, $v_i$, $c_i$ represent $i$-th edge of the flow network. A pair of $u_i$ and $v_i$ denotes that there is an edge from $u_i$ to $v_i$ and $c_i$ is the capacity of $i$-th edge.
Output
Print the maximum flow.
Example
Input
4 5
0 1 2
0 2 1
1 2 1
1 3 1
2 3 2
Output
3
### Response
```cpp
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
using namespace std;
//
struct edge{int to;int cap;int rev;};
struct Dinic{
//
int v;
vector<edge> G[1000];
vector<int> lel,ite;
//
Dinic(int n){
v=n;
lel.resize(v);
ite.resize(v);
}
//
void add_edge(int from,int to,int cap){
G[from].push_back((edge){to,cap,(int)G[to].size()});
G[to].push_back((edge){from,0,(int)G[from].size()-1});
}
//
void BFS(int s){
fill(lel.begin(),lel.end(),-1);
queue<int> que;
lel[s]=0;
que.push(s);
while(!que.empty()){
int v=que.front();que.pop();
for(int i=0;i<G[v].size();i++){
edge &e=G[v][i];
if(e.cap>0&&lel[e.to]<0){
lel[e.to]=lel[v]+1;
que.push(e.to);
}
}
}
}
//
int DFS(int v,int t,int f){
if(v==t){
return f;
}
for(int i=ite[v];i<G[v].size();i++){
edge &e=G[v][i];
if(e.cap>0&&lel[v]<lel[e.to]){
int d=DFS(e.to,t,min(f,e.cap));
if(d>0){
e.cap-=d;
G[e.to][e.rev].cap+=d;
return d;
}
}
}
return 0;
}
//
int max_flow(int s,int t){
int flow=0;
while(1){
BFS(s);
if(lel[t]<0){
return flow;
}else{
fill(ite.begin(),ite.end(),0);
int f;
while((f=DFS(s,t,1e9+7))>0){
flow+=f;
}
}
}
}
//
};
//
int main(){
int V,E;
cin>>V>>E;
Dinic DC(V);
for(int i=0;i<E;i++){
int s,t,c;
cin>>s>>t>>c;
DC.add_edge(s,t,c);
}
cout<<DC.max_flow(0,V-1)<<endl;
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
You are given a string s consisting of n lowercase Latin letters.
You have to remove at most one (i.e. zero or one) character of this string in such a way that the string you obtain will be lexicographically smallest among all strings that can be obtained using this operation.
String s = s_1 s_2 ... s_n is lexicographically smaller than string t = t_1 t_2 ... t_m if n < m and s_1 = t_1, s_2 = t_2, ..., s_n = t_n or there exists a number p such that p β€ min(n, m) and s_1 = t_1, s_2 = t_2, ..., s_{p-1} = t_{p-1} and s_p < t_p.
For example, "aaa" is smaller than "aaaa", "abb" is smaller than "abc", "pqr" is smaller than "z".
Input
The first line of the input contains one integer n (2 β€ n β€ 2 β
10^5) β the length of s.
The second line of the input contains exactly n lowercase Latin letters β the string s.
Output
Print one string β the smallest possible lexicographically string that can be obtained by removing at most one character from the string s.
Examples
Input
3
aaa
Output
aa
Input
5
abcda
Output
abca
Note
In the first example you can remove any character of s to obtain the string "aa".
In the second example "abca" < "abcd" < "abcda" < "abda" < "acda" < "bcda".
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
int main() {
int n;
cin >> n;
string s;
cin >> s;
int no = 1;
for (int i = 1; i < n && no; i++) {
if (s[i] < s[i - 1]) {
s.erase(s.begin() + i - 1);
no = 0;
cout << s;
return 0;
}
}
s.pop_back();
cout << s;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
Robbers, who attacked the Gerda's cab, are very successful in covering from the kingdom police. To make the goal of catching them even harder, they use their own watches.
First, as they know that kingdom police is bad at math, robbers use the positional numeral system with base 7. Second, they divide one day in n hours, and each hour in m minutes. Personal watches of each robber are divided in two parts: first of them has the smallest possible number of places that is necessary to display any integer from 0 to n - 1, while the second has the smallest possible number of places that is necessary to display any integer from 0 to m - 1. Finally, if some value of hours or minutes can be displayed using less number of places in base 7 than this watches have, the required number of zeroes is added at the beginning of notation.
Note that to display number 0 section of the watches is required to have at least one place.
Little robber wants to know the number of moments of time (particular values of hours and minutes), such that all digits displayed on the watches are distinct. Help her calculate this number.
Input
The first line of the input contains two integers, given in the decimal notation, n and m (1 β€ n, m β€ 109) β the number of hours in one day and the number of minutes in one hour, respectively.
Output
Print one integer in decimal notation β the number of different pairs of hour and minute, such that all digits displayed on the watches are distinct.
Examples
Input
2 3
Output
4
Input
8 2
Output
5
Note
In the first sample, possible pairs are: (0: 1), (0: 2), (1: 0), (1: 2).
In the second sample, possible pairs are: (02: 1), (03: 1), (04: 1), (05: 1), (06: 1).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int a, n, m, i, j, k, l1, l2, ans = 0;
cin >> n >> m;
l1 = l2 = 1;
for (i = 7; i < n; i *= 7) l1++;
for (i = 7; i < m; i *= 7) l2++;
if (l1 + l2 <= 7) {
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
vector<long long int> used(7, 0);
for (a = i, k = 0; k < l1; k++, a /= 7) used[a % 7]++;
for (a = j, k = 0; k < l2; k++, a /= 7) used[a % 7]++;
if (*max_element(used.begin(), used.end()) <= 1) ans++;
}
}
}
cout << ans << "\n";
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
Galya is playing one-dimensional Sea Battle on a 1 Γ n grid. In this game a ships are placed on the grid. Each of the ships consists of b consecutive cells. No cell can be part of two ships, however, the ships can touch each other.
Galya doesn't know the ships location. She can shoot to some cells and after each shot she is told if that cell was a part of some ship (this case is called "hit") or not (this case is called "miss").
Galya has already made k shots, all of them were misses.
Your task is to calculate the minimum number of cells such that if Galya shoot at all of them, she would hit at least one ship.
It is guaranteed that there is at least one valid ships placement.
Input
The first line contains four positive integers n, a, b, k (1 β€ n β€ 2Β·105, 1 β€ a, b β€ n, 0 β€ k β€ n - 1) β the length of the grid, the number of ships on the grid, the length of each ship and the number of shots Galya has already made.
The second line contains a string of length n, consisting of zeros and ones. If the i-th character is one, Galya has already made a shot to this cell. Otherwise, she hasn't. It is guaranteed that there are exactly k ones in this string.
Output
In the first line print the minimum number of cells such that if Galya shoot at all of them, she would hit at least one ship.
In the second line print the cells Galya should shoot at.
Each cell should be printed exactly once. You can print the cells in arbitrary order. The cells are numbered from 1 to n, starting from the left.
If there are multiple answers, you can print any of them.
Examples
Input
5 1 2 1
00100
Output
2
4 2
Input
13 3 2 3
1000000010001
Output
2
7 11
Note
There is one ship in the first sample. It can be either to the left or to the right from the shot Galya has already made (the "1" character). So, it is necessary to make two shots: one at the left part, and one at the right part.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 30;
const int N = 2e5 + 10;
char s[N];
int main() {
int n, A, B, k;
scanf("%d%d%d%d", &n, &A, &B, &k);
scanf("%s", s);
vector<pair<int, int> > a;
int sum = 0;
for (int i = 0, j; i < n; i = j) {
for (; i < n && s[i] == '1'; ++i)
;
for (j = i + 1; j < n && s[j] == '0'; ++j)
;
a.push_back(pair<int, int>{i, j});
sum += (j - i) / B;
}
vector<int> ret;
for (int i = 0; i < a.size() && sum >= A; ++i) {
int last = a[i].first - 1;
while (last + B < a[i].second && sum >= A) {
ret.push_back(last + B);
last += B;
sum--;
}
}
printf("%d\n", ret.size());
for (int i = 0; i < ret.size(); ++i) {
printf("%d%c", ret[i] + 1, " \n"[i == ret.size() - 1]);
}
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
The University of Aizu has a park covered with grass, and there are no trees or buildings that block the sunlight. On sunny summer days, sprinklers installed in the park operate to sprinkle water on the lawn. The frog Pyonkichi lives in this park. Pyonkichi is not good at hot weather, and on summer days when the sun is strong, he will dry out and die if he is not exposed to the water of the sprinkler. The sprinklers installed in the park are supposed to sprinkle only one sprinkler at a time to save water, so Pyonkichi must move according to the operation of the sprinklers.
<image>
---
(a) Map of the park
<image> | <image>
--- | ---
(b) Pyonkichi's jump range | (c) Sprinkler watering range
The park is as shown in (a) of the above figure, the location in the park is represented by the coordinates 0 to 9 in each of the vertical and horizontal directions, and the black β is the sprinkler, which indicates the order in which the numbers operate. This is just an example, and the location and order of operation of each sprinkler changes daily.
Pyonkichi is clumsy, so he can only jump a certain distance to move. Pyonkichi's jumpable range is as shown in (b) above, and he cannot move to any other location. Moreover, one jump consumes a lot of physical strength, so you have to rest in the water for a while.
The range in which the sprinkler can sprinkle water is as shown in the above figure (c), including the coordinates of the sprinkler itself. Each sprinkler will stop after a period of watering, and the next sprinkler will start working immediately. Pyonkichi shall jump only once at this time, and shall not jump until the next watering stops. Also, since the park is surrounded on all sides by scorching asphalt, it is assumed that you will not jump in a direction that would cause you to go out of the park.
This summer was extremely hot. Was Pyonkichi able to survive? One day, read the initial position of Pyonkichi, the position of the sprinkler and the operation order, and if there is a movement path that Pyonkichi can survive, "OK", how? If you die even if you do your best, create a program that outputs "NA". However, the maximum number of sprinklers is 10, and Pyonkichi will jump from the initial position at the same time as the first sprinkler is activated.
Input
Given multiple datasets. Each dataset is given in the following format:
px py
n
x1 y1 x2 y2 ... xn yn
The first line gives the abscissa px and ordinate py of the initial position of Pyonkichi. The second line gives the number of sprinklers n. The third line gives the abscissa xi and the ordinate yi of the sprinkler that operates third.
The input ends with two zero lines. The number of datasets does not exceed 20.
Output
For each dataset, print OK if it is alive, or NA on one line otherwise.
Example
Input
6 1
10
6 4 3 3 1 2 0 5 4 6 1 8 5 9 7 7 8 6 8 3
6 1
10
6 4 3 3 1 2 0 5 4 6 1 8 5 9 7 7 8 6 9 0
0 0
Output
OK
NA
### Response
```cpp
#include <iostream>
#include <fstream>
#include <sstream>
#include <iomanip>
#include <complex>
#include <string>
#include <vector>
#include <list>
#include <deque>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <bitset>
#include <functional>
#include <utility>
#include <algorithm>
#include <numeric>
#include <typeinfo>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <climits>
#include <ctime>
using namespace std;
#define dump(n) cout<<"# "<<#n<<"="<<(n)<<endl
#define debug(n) cout<<__FILE__<<","<<__LINE__<<": #"<<#n<<"="<<(n)<<endl
#define repi(i,a,b) for(int i=int(a);i<int(b);i++)
#define rep(i,n) repi(i,0,n)
#define iter(c) __typeof((c).begin())
#define foreach(i,c) for(iter(c) i=(c).begin();i!=(c).end();i++)
#define allof(c) (c).begin(),(c).end()
#define mp make_pair
typedef unsigned int uint;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<string> vs;
typedef pair<int,int> pii;
string solve(pii f,vector<pii> w)
{
int di[]={-2,-2,-2,2,2,2,-1,0,1,-1,0,1};
int dj[]={-1,0,1,-1,0,1,-2,-2,-2,2,2,2};
int n=w.size();
queue<pair<int,pii> > q;
rep(i,12)
q.push(mp(0,mp(f.first+di[i],f.second+dj[i])));
while(q.size()){
int cur=q.front().first;
pii curp=q.front().second;
q.pop();
if(cur==n)
return "OK";
int curi=curp.first,curj=curp.second;
if(curi<0 || 10<=curi || curj<0 || 10<=curj)
continue;
if(max(abs(curi-w[cur].first),abs(curj-w[cur].second))>1)
continue;
rep(i,12)
q.push(mp(cur+1,mp(curi+di[i],curj+dj[i])));
}
return "NA";
}
int main()
{
for(pii f;cin>>f.first>>f.second,f.first|f.second;){
int n;
cin>>n;
vector<pii> w(n);
rep(i,n)
cin>>w[i].first>>w[i].second;
cout<<solve(f,w)<<endl;
}
return 0;
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
Just to remind, girls in Arpa's land are really nice.
Mehrdad wants to invite some Hoses to the palace for a dancing party. Each Hos has some weight wi and some beauty bi. Also each Hos may have some friends. Hoses are divided in some friendship groups. Two Hoses x and y are in the same friendship group if and only if there is a sequence of Hoses a1, a2, ..., ak such that ai and ai + 1 are friends for each 1 β€ i < k, and a1 = x and ak = y.
<image>
Arpa allowed to use the amphitheater of palace to Mehrdad for this party. Arpa's amphitheater can hold at most w weight on it.
Mehrdad is so greedy that he wants to invite some Hoses such that sum of their weights is not greater than w and sum of their beauties is as large as possible. Along with that, from each friendship group he can either invite all Hoses, or no more than one. Otherwise, some Hoses will be hurt. Find for Mehrdad the maximum possible total beauty of Hoses he can invite so that no one gets hurt and the total weight doesn't exceed w.
Input
The first line contains integers n, m and w (1 β€ n β€ 1000, <image>, 1 β€ w β€ 1000) β the number of Hoses, the number of pair of friends and the maximum total weight of those who are invited.
The second line contains n integers w1, w2, ..., wn (1 β€ wi β€ 1000) β the weights of the Hoses.
The third line contains n integers b1, b2, ..., bn (1 β€ bi β€ 106) β the beauties of the Hoses.
The next m lines contain pairs of friends, the i-th of them contains two integers xi and yi (1 β€ xi, yi β€ n, xi β yi), meaning that Hoses xi and yi are friends. Note that friendship is bidirectional. All pairs (xi, yi) are distinct.
Output
Print the maximum possible total beauty of Hoses Mehrdad can invite so that no one gets hurt and the total weight doesn't exceed w.
Examples
Input
3 1 5
3 2 5
2 4 2
1 2
Output
6
Input
4 2 11
2 4 6 6
6 4 2 1
1 2
2 3
Output
7
Note
In the first sample there are two friendship groups: Hoses {1, 2} and Hos {3}. The best way is to choose all of Hoses in the first group, sum of their weights is equal to 5 and sum of their beauty is 6.
In the second sample there are two friendship groups: Hoses {1, 2, 3} and Hos {4}. Mehrdad can't invite all the Hoses from the first group because their total weight is 12 > 11, thus the best way is to choose the first Hos from the first group and the only one from the second group. The total weight will be 8, and the total beauty will be 7.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e6 + 5;
long long z, n, m, sb, sw, x, y, W, maxx, dp[maxn], b[maxn], w[maxn];
vector<pair<long long, long long> > gp;
vector<int> g[maxn];
bool mark[maxn];
void dfs(int v) {
gp.push_back({w[v], b[v]}), mark[v] = 1;
for (auto u : g[v]) {
if (!mark[u]) dfs(u);
}
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m >> W;
for (int i = 0; i < n; i++) cin >> w[i];
for (int i = 0; i < n; i++) cin >> b[i];
for (int i = 0; i < m; i++) {
cin >> x >> y, x--, y--;
g[x].push_back(y), g[y].push_back(x);
}
for (int i = 0; i < n; i++) {
if (!mark[i]) {
gp.clear();
sw = 0, sb = 0, dfs(i);
for (auto u : gp) sw += u.first, sb += u.second;
gp.push_back({sw, sb});
for (int j = W; j >= 0; j--)
for (auto u : gp)
if (j >= u.first) dp[j] = max(dp[j], dp[j - u.first] + u.second);
}
}
cout << dp[W];
return 0;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
We all know that GukiZ often plays with arrays.
Now he is thinking about this problem: how many arrays a, of length n, with non-negative elements strictly less then 2l meet the following condition: <image>? Here operation <image> means bitwise AND (in Pascal it is equivalent to and, in C/C++/Java/Python it is equivalent to &), operation <image> means bitwise OR (in Pascal it is equivalent to <image>, in C/C++/Java/Python it is equivalent to |).
Because the answer can be quite large, calculate it modulo m. This time GukiZ hasn't come up with solution, and needs you to help him!
Input
First and the only line of input contains four integers n, k, l, m (2 β€ n β€ 1018, 0 β€ k β€ 1018, 0 β€ l β€ 64, 1 β€ m β€ 109 + 7).
Output
In the single line print the number of arrays satisfying the condition above modulo m.
Examples
Input
2 1 2 10
Output
3
Input
2 1 1 3
Output
1
Input
3 3 2 10
Output
9
Note
In the first sample, satisfying arrays are {1, 1}, {3, 1}, {1, 3}.
In the second sample, only satisfying array is {1, 1}.
In the third sample, satisfying arrays are {0, 3, 3}, {1, 3, 2}, {1, 3, 3}, {2, 3, 1}, {2, 3, 3}, {3, 3, 0}, {3, 3, 1}, {3, 3, 2}, {3, 3, 3}.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long mod;
long long quickpow(long long a, long long x) {
long long res = 1;
while (x) {
if (x & 1) res = res * a % mod;
a = a * a % mod;
x >>= 1;
}
return res;
}
const int maxn = 2;
int num = 2;
struct mat {
long long data[maxn][maxn];
void one() {
init();
for (int i = 0; i < num; i++) data[i][i] = 1;
}
inline void init() { memset(data, 0, sizeof(data)); }
} st;
mat copy(const mat& a) {
mat c;
for (int i = 0; i < num; i++)
for (int j = 0; j < num; j++) c.data[i][j] = a.data[i][j];
return c;
}
mat operator*(const mat& a, const mat& b) {
mat c;
c.init();
for (int k = 0; k < num; k++) {
for (int i = 0; i < num; i++) {
if (!a.data[i][k]) continue;
for (int j = 0; j < num; j++) {
c.data[i][j] += a.data[i][k] * b.data[k][j];
c.data[i][j] %= mod;
}
}
}
return c;
}
mat operator+(const mat& a, const mat& b) {
mat c;
for (int i = 0; i < num; i++)
for (int j = 0; j < num; j++)
c.data[i][j] = (a.data[i][j] + b.data[i][j]) % mod;
return c;
}
mat operator^(const mat& aa, long long k) {
mat a = copy(aa);
mat c;
c.one();
for (; k; k >>= 1) {
if (k & 1) c = c * a;
a = a * a;
}
return c;
}
long long n, r, le;
int main() {
cin >> n >> r >> le >> mod;
long long ans = 1 % mod;
st.init();
st.data[0][1] = st.data[1][0] = st.data[1][1] = 1;
mat s = st ^ (n - 1);
long long d0 = (s.data[0][0] + s.data[0][1]) % mod;
long long d1 = (s.data[1][0] + s.data[1][1]) % mod;
d0 = (d0 + d1) % mod;
d1 = ((quickpow(2, n) - d0) % mod + mod) % mod;
for (int i = 0; i < le; i++) {
if (i < 60) {
if (r & (1ll << i)) {
ans = ans * d1 % mod;
r -= (1ll << i);
} else
ans = ans * d0 % mod;
} else
ans = ans * d0 % mod;
}
if (r) ans = 0;
cout << ans << endl;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
You and your n - 1 friends have found an array of integers a_1, a_2, ..., a_n. You have decided to share it in the following way: All n of you stand in a line in a particular order. Each minute, the person at the front of the line chooses either the first or the last element of the array, removes it, and keeps it for himself. He then gets out of line, and the next person in line continues the process.
You are standing in the m-th position in the line. Before the process starts, you may choose up to k different people in the line, and persuade them to always take either the first or the last element in the array on their turn (for each person his own choice, not necessarily equal for all people), no matter what the elements themselves are. Once the process starts, you cannot persuade any more people, and you cannot change the choices for the people you already persuaded.
Suppose that you're doing your choices optimally. What is the greatest integer x such that, no matter what are the choices of the friends you didn't choose to control, the element you will take from the array will be greater than or equal to x?
Please note that the friends you don't control may do their choice arbitrarily, and they will not necessarily take the biggest element available.
Input
The input consists of multiple test cases. The first line contains a single integer t (1 β€ t β€ 1000) β the number of test cases. The description of the test cases follows.
The first line of each test case contains three space-separated integers n, m and k (1 β€ m β€ n β€ 3500, 0 β€ k β€ n - 1) β the number of elements in the array, your position in line and the number of people whose choices you can fix.
The second line of each test case contains n positive integers a_1, a_2, ..., a_n (1 β€ a_i β€ 10^9) β elements of the array.
It is guaranteed that the sum of n over all test cases does not exceed 3500.
Output
For each test case, print the largest integer x such that you can guarantee to obtain at least x.
Example
Input
4
6 4 2
2 9 2 3 8 5
4 4 1
2 13 60 4
4 1 3
1 2 2 1
2 2 0
1 2
Output
8
4
1
1
Note
In the first test case, an optimal strategy is to force the first person to take the last element and the second person to take the first element.
* the first person will take the last element (5) because he or she was forced by you to take the last element. After this turn the remaining array will be [2, 9, 2, 3, 8];
* the second person will take the first element (2) because he or she was forced by you to take the first element. After this turn the remaining array will be [9, 2, 3, 8];
* if the third person will choose to take the first element (9), at your turn the remaining array will be [2, 3, 8] and you will take 8 (the last element);
* if the third person will choose to take the last element (8), at your turn the remaining array will be [9, 2, 3] and you will take 9 (the first element).
Thus, this strategy guarantees to end up with at least 8. We can prove that there is no strategy that guarantees to end up with at least 9. Hence, the answer is 8.
In the second test case, an optimal strategy is to force the first person to take the first element. Then, in the worst case, both the second and the third person will take the first element: you will end up with 4.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, m, k;
cin >> n >> m >> k;
vector<int> a(n);
for (auto& x : a) {
cin >> x;
}
vector<int> b(m);
for (int i = 0; i < m; i++) {
b[i] = max(a[i], a[i + n - m]);
}
k = min(k, m - 1);
int d = m - k;
int res = 0;
for (int i = 0; i + d <= m; i++) {
int mi = 1e9;
for (int j = i; j < i + d; j++) {
mi = min(mi, b[j]);
}
res = max(res, mi);
}
cout << res << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int T;
cin >> T;
for (int t = 0; t < T; t++) {
solve();
}
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
As AtCoder Beginner Contest 100 is taking place, the office of AtCoder, Inc. is decorated with a sequence of length N, a = {a_1, a_2, a_3, ..., a_N}.
Snuke, an employee, would like to play with this sequence.
Specifically, he would like to repeat the following operation as many times as possible:
For every i satisfying 1 \leq i \leq N, perform one of the following: "divide a_i by 2" and "multiply a_i by 3".
Here, choosing "multiply a_i by 3" for every i is not allowed, and the value of a_i after the operation must be an integer.
At most how many operations can be performed?
Constraints
* N is an integer between 1 and 10 \ 000 (inclusive).
* a_i is an integer between 1 and 1 \ 000 \ 000 \ 000 (inclusive).
Input
Input is given from Standard Input in the following format:
N
a_1 a_2 a_3 ... a_N
Output
Print the maximum number of operations that Snuke can perform.
Examples
Input
3
5 2 4
Output
3
Input
4
631 577 243 199
Output
0
Input
10
2184 2126 1721 1800 1024 2528 3360 1945 1280 1776
Output
39
### Response
```cpp
#include<iostream>
using namespace std;
int n,cnt,a,i;
int main(){
cin>>n;
for(i=0;i<n;i++){
cin>>a;
while(a%2!=1){
a/=2;
cnt++;
}
}
cout<<cnt<<endl;
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
Giant chess is quite common in Geraldion. We will not delve into the rules of the game, we'll just say that the game takes place on an h Γ w field, and it is painted in two colors, but not like in chess. Almost all cells of the field are white and only some of them are black. Currently Gerald is finishing a game of giant chess against his friend Pollard. Gerald has almost won, and the only thing he needs to win is to bring the pawn from the upper left corner of the board, where it is now standing, to the lower right corner. Gerald is so confident of victory that he became interested, in how many ways can he win?
The pawn, which Gerald has got left can go in two ways: one cell down or one cell to the right. In addition, it can not go to the black cells, otherwise the Gerald still loses. There are no other pawns or pieces left on the field, so that, according to the rules of giant chess Gerald moves his pawn until the game is over, and Pollard is just watching this process.
Input
The first line of the input contains three integers: h, w, n β the sides of the board and the number of black cells (1 β€ h, w β€ 105, 1 β€ n β€ 2000).
Next n lines contain the description of black cells. The i-th of these lines contains numbers ri, ci (1 β€ ri β€ h, 1 β€ ci β€ w) β the number of the row and column of the i-th cell.
It is guaranteed that the upper left and lower right cell are white and all cells in the description are distinct.
Output
Print a single line β the remainder of the number of ways to move Gerald's pawn from the upper left to the lower right corner modulo 109 + 7.
Examples
Input
3 4 2
2 2
2 3
Output
2
Input
100 100 3
15 16
16 15
99 88
Output
545732279
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int mod = (int)1e9 + 7;
long long fac[200500], facinv[200500];
int h, w, n;
int x[2005], y[2005];
long long dp[2005];
long long fp(long long x, long long k) {
if (k == 0) return 1;
long long hf = fp(x, k / 2);
return k % 2 ? hf * hf % mod * x % mod : hf * hf % mod;
}
long long Comb(int n, int k) {
return fac[n] * facinv[k] % mod * facinv[n - k] % mod;
}
bool should(int i, int j) { return x[j] <= x[i] && y[j] <= y[i]; }
long long get(int i) {
if (dp[i] != -1) return dp[i];
long long res = Comb(x[i] + y[i] - 2, x[i] - 1);
for (int j = 1; j <= n; j++) {
if (i != j && should(i, j))
res = (res - get(j) * Comb(x[i] - x[j] + y[i] - y[j], x[i] - x[j]) % mod +
mod) %
mod;
}
return dp[i] = res;
}
int main() {
fac[0] = 1;
for (int i = 1; i <= 200000; i++) fac[i] = fac[i - 1] * i % mod;
facinv[200000] = fp(fac[200000], mod - 2);
for (int i = 200000 - 1; i >= 0; i--)
facinv[i] = facinv[i + 1] * (i + 1) % mod;
fill(dp, dp + 2005, -1);
scanf("%d%d%d", &h, &w, &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &x[i], &y[i]);
}
x[0] = h, y[0] = w;
cout << get(0) << endl;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
Memory and his friend Lexa are competing to get higher score in one popular computer game. Memory starts with score a and Lexa starts with score b. In a single turn, both Memory and Lexa get some integer in the range [ - k;k] (i.e. one integer among - k, - k + 1, - k + 2, ..., - 2, - 1, 0, 1, 2, ..., k - 1, k) and add them to their current scores. The game has exactly t turns. Memory and Lexa, however, are not good at this game, so they both always get a random integer at their turn.
Memory wonders how many possible games exist such that he ends with a strictly higher score than Lexa. Two games are considered to be different if in at least one turn at least one player gets different score. There are (2k + 1)2t games in total. Since the answer can be very large, you should print it modulo 109 + 7. Please solve this problem for Memory.
Input
The first and only line of input contains the four integers a, b, k, and t (1 β€ a, b β€ 100, 1 β€ k β€ 1000, 1 β€ t β€ 100) β the amount Memory and Lexa start with, the number k, and the number of turns respectively.
Output
Print the number of possible games satisfying the conditions modulo 1 000 000 007 (109 + 7) in one line.
Examples
Input
1 2 2 1
Output
6
Input
1 1 1 2
Output
31
Input
2 12 3 1
Output
0
Note
In the first sample test, Memory starts with 1 and Lexa starts with 2. If Lexa picks - 2, Memory can pick 0, 1, or 2 to win. If Lexa picks - 1, Memory can pick 1 or 2 to win. If Lexa picks 0, Memory can pick 2 to win. If Lexa picks 1 or 2, Memory cannot win. Thus, there are 3 + 2 + 1 = 6 possible games in which Memory wins.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAX = 4e5 + 7;
const int le = 2e5;
const int mod = 1e9 + 7;
long long a, b, k, t;
long long dp[2][MAX];
long long sum[MAX];
int now = 0, pre = 1;
int main() {
scanf("%lld%lld%lld%lld", &a, &b, &k, &t);
dp[now][le] = 1;
for (int i = 1; i <= t; i++) {
for (int j = 1; j < MAX; j++) {
sum[j] = dp[now][j] + sum[j - 1];
sum[j] %= mod;
}
swap(now, pre);
memset(dp[now], 0, sizeof(dp[now]));
for (int j = 1; j < MAX; j++) {
dp[now][j] += sum[min(MAX - 1LL, j + k)] - sum[max(0LL, j - k - 1)];
dp[now][j] %= mod;
}
}
for (int j = 1; j < MAX; j++) {
sum[j] = dp[now][j] + sum[j - 1];
sum[j] %= mod;
}
long long ans = 0;
for (int j = 0; j < MAX; j++) {
ans += sum[a + j - b - 1] % mod * dp[now][j] % mod;
ans %= mod;
}
cout << (ans + mod) % mod << endl;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
There are N people, conveniently numbered 1 through N. We want to divide them into some number of groups, under the following two conditions:
* Every group contains between A and B people, inclusive.
* Let F_i be the number of the groups containing exactly i people. Then, for all i, either F_i=0 or Cβ€F_iβ€D holds.
Find the number of these ways to divide the people into groups. Here, two ways to divide them into groups is considered different if and only if there exists two people such that they belong to the same group in exactly one of the two ways. Since the number of these ways can be extremely large, print the count modulo 10^9+7.
Constraints
* 1β€Nβ€10^3
* 1β€Aβ€Bβ€N
* 1β€Cβ€Dβ€N
Input
The input is given from Standard Input in the following format:
N A B C D
Output
Print the number of ways to divide the people into groups under the conditions, modulo 10^9+7.
Examples
Input
3 1 3 1 2
Output
4
Input
7 2 3 1 3
Output
105
Input
1000 1 1000 1 1000
Output
465231251
Input
10 3 4 2 5
Output
0
### Response
```cpp
#include <iostream>
#include <cstdio>
#define N 1005
using namespace std;
typedef long long ll;
ll n, a, b, c, d, M=1e9+7, dp[N]={1}, fac[N]={1}, fiv[N]={1};
ll pow(ll p, ll q) {
return q ? pow(p*p%M, q/2) * (q&1 ? p : 1) % M : 1;
}
int main() {
ll i, j, k;
cin >> n >> a >> b >> c >> d;
for(i=1; i<=n; i++) {
fac[i] = fac[i-1] * i % M;
fiv[i] = pow(fac[i], M-2);
}
for(i=a; i<=b; i++) for(j=n; j>=0; j--) for(k=c; k<=d && j-k*i>=0; k++) {
dp[j] = (dp[j] + dp[j-k*i] * pow(fiv[i], k) % M * fiv[k]) % M;
}
cout << dp[n] * fac[n] % M;
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
Taro and Hanako are playing card games. They have n cards each, and they compete n turns. At each turn Taro and Hanako respectively puts out a card. The name of the animal consisting of alphabetical letters is written on each card, and the bigger one in lexicographical order becomes the winner of that turn. The winner obtains 3 points. In the case of a draw, they obtain 1 point each.
Write a program which reads a sequence of cards Taro and Hanako have and reports the final scores of the game.
Constraints
* n β€ 1000
* The length of the string β€ 100
Input
In the first line, the number of cards n is given. In the following n lines, the cards for n turns are given respectively. For each line, the first string represents the Taro's card and the second one represents Hanako's card.
Output
Print the final scores of Taro and Hanako respectively. Put a single space character between them.
Example
Input
3
cat dog
fish fish
lion tiger
Output
1 7
### Response
```cpp
#include<iostream>
#include<string>
using namespace std;
int main(){
int n,a=0,b=0;
string x,y;
cin >> n;
for(int i=0;i<n;i++){
cin >> x >> y;
if(x>y) a+=3;
else if(x<y) b+=3;
else{
a++;
b++;
}
}cout << a << " " << b << endl;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Galya is playing one-dimensional Sea Battle on a 1 Γ n grid. In this game a ships are placed on the grid. Each of the ships consists of b consecutive cells. No cell can be part of two ships, however, the ships can touch each other.
Galya doesn't know the ships location. She can shoot to some cells and after each shot she is told if that cell was a part of some ship (this case is called "hit") or not (this case is called "miss").
Galya has already made k shots, all of them were misses.
Your task is to calculate the minimum number of cells such that if Galya shoot at all of them, she would hit at least one ship.
It is guaranteed that there is at least one valid ships placement.
Input
The first line contains four positive integers n, a, b, k (1 β€ n β€ 2Β·105, 1 β€ a, b β€ n, 0 β€ k β€ n - 1) β the length of the grid, the number of ships on the grid, the length of each ship and the number of shots Galya has already made.
The second line contains a string of length n, consisting of zeros and ones. If the i-th character is one, Galya has already made a shot to this cell. Otherwise, she hasn't. It is guaranteed that there are exactly k ones in this string.
Output
In the first line print the minimum number of cells such that if Galya shoot at all of them, she would hit at least one ship.
In the second line print the cells Galya should shoot at.
Each cell should be printed exactly once. You can print the cells in arbitrary order. The cells are numbered from 1 to n, starting from the left.
If there are multiple answers, you can print any of them.
Examples
Input
5 1 2 1
00100
Output
2
4 2
Input
13 3 2 3
1000000010001
Output
2
7 11
Note
There is one ship in the first sample. It can be either to the left or to the right from the shot Galya has already made (the "1" character). So, it is necessary to make two shots: one at the left part, and one at the right part.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, k, len, p;
cin >> n >> k >> len >> p;
string s;
cin >> s;
s += "1";
n += 1;
long long maxx = 0, zero = 0;
for (long long i = 0; i < n; i++) {
if (s[i] == '0') {
zero += 1;
} else {
maxx += zero / len;
zero = 0;
}
}
zero = 0;
vector<long long> ans;
for (long long i = 0; i < n; i++) {
if (s[i] == '0') {
zero += 1;
if (zero % len == 0) {
ans.push_back(i + 1);
maxx -= 1;
if (maxx < k) break;
}
} else
zero = 0;
}
cout << ans.size() << "\n";
for (auto i : ans) cout << i << " ";
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
In Finite Encyclopedia of Integer Sequences (FEIS), all integer sequences of lengths between 1 and N (inclusive) consisting of integers between 1 and K (inclusive) are listed.
Let the total number of sequences listed in FEIS be X. Among those sequences, find the (X/2)-th (rounded up to the nearest integer) lexicographically smallest one.
Constraints
* 1 \leq N,K \leq 3 Γ 10^5
* N and K are integers.
Input
Input is given from Standard Input in the following format:
K N
Output
Print the (X/2)-th (rounded up to the nearest integer) lexicographically smallest sequence listed in FEIS, with spaces in between, where X is the total number of sequences listed in FEIS.
Examples
Input
3 2
Output
2 1
Input
2 4
Output
1 2 2 2
Input
5 14
Output
3 3 3 3 3 3 3 3 3 3 3 3 2 2
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0; i<(n); i++)
const int MX = 300005;
int n,k;
int main(){
scanf("%d%d", &k, &n);
if(~k&1) rep(i,n) printf("%d%c", i?k:k/2,i<n-1?' ':'\n');
else{
int d[MX] = {}, e = n-1;
fill(d,d+n,k/2+1);
rep(i,n/2){
d[e]--;
if(!d[e]) e--;
else if(e < n-1) for(;e < n-1; e++) d[e+1] = k;
}
rep(i,e+1) printf("%d%c", d[i],i<e?' ':'\n');
}
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
Problem C: Seishun 18 Kippu
A student at R University, sirokurostone, was about to attend a training camp at Atsu University. Other members plan to use the Shinkansen, but sirokurostone was going to use the Seishun 18 Ticket. Similarly, a person who likes 2D with a youth 18 ticket was also trying to participate in the training camp.
Sirokurostone, who wanted to go with him anyway, decided to pick up him who likes 2D at the station on the way. sirokurostone wants to check the delay situation before leaving R University and take a route that takes less time to reach the station where Atsu University is located. sirokurostone intends to give that information to him who likes 2D after the route is confirmed. However, sirokurostone is in trouble because he does not know which route to take to reach the station where Atsu University is located sooner even if he sees the delay situation.
So your job is to find out how long it will take to get to the station where Atsu University is located on behalf of sirokurostone from the delay situation.
Between each station, there is a distance between stations and an estimated delay time. The train shall maintain 40km / h after it starts moving. The travel time between points a and b is
* Distance / 40+ estimated delay time
Can be obtained at. The stop time at each station can be ignored.
Input
A sequence of multiple datasets is given as input. The number of datasets is guaranteed to be 50 or less. Each dataset has the following format:
n m
s p g
a1 b1 d1 t1
...
ai bi di ti
...
am bm dm tm
The integers n (3 β€ n β€ 500) and m (2 β€ m β€ 5000) represent the total number of stations and the number of tracks between each station, respectively. s, p, and g are character strings that indicate the location of the station where sirokurostone rides, the station where a person who likes 2D rides, and the station where Atsu University is located, respectively. s, p, and g are different character strings.
The following m line represents the information between stations. ai and bi are character strings indicating stations connected by railroad tracks. ai and bi can go back and forth in both directions. ai and bi never match. The integer di (40 β€ di β€ 10000) represents the distance between ai and bi. di is guaranteed to be a multiple of 40. The integer ti (0 β€ ti β€ 20) indicates the estimated delay time between ai and bi.
The character string representing the station name is represented by a character string of 20 characters or less consisting of all lowercase and uppercase letters of the alphabet. There is at most one track between stations.
The end of the input is represented by a line containing two zeros.
Output
For each input dataset, output the arrival time (unit: time) to the station where Atsu University is located. It is guaranteed that there is a route from the station where sirokurostone rides to the station where 2D lovers ride, and a route from the station where 2D lovers ride to the station where Atsu University is located.
Sample Input
4 4
A B G
A B 40 3
B C 80 0
A G 40 0
B G 80 0
5 6
Kusatsu Tokyo Aizu
Tokyo Nagoya 120 3
Kusatsu Nagoya 40 0
Kusatsu Kanazawa 40 0
Kanazawa Aizu 40 0
Tokyo Kanazawa 40 0
Tokyo Aizu 80 4
0 0
Output for Sample Input
Five
Four
Example
Input
4 4
A B G
A B 40 3
B C 80 0
A G 40 0
B G 80 0
5 6
Kusatsu Tokyo Aizu
Tokyo Nagoya 120 3
Kusatsu Nagoya 40 0
Kusatsu Kanazawa 40 0
Kanazawa Aizu 40 0
Tokyo Kanazawa 40 0
Tokyo Aizu 80 4
0 0
Output
5
4
### Response
```cpp
//11
#include<iostream>
#include<set>
#include<map>
using namespace std;
int dik(map<string,map<string,int> > d,string s,string g){
set<string> p;
map<string,int> n;
n[s]=0;
for(int i=0;i<d.size();i++){
int nm=1<<30;
string ns;
for(map<string,int>::iterator it=n.begin();it!=n.end();it++){
if(!p.count(it->first)&&it->second<nm){
nm=it->second;
ns=it->first;
}
}
p.insert(ns);
for(map<string,int>::iterator it=d[ns].begin();it!=d[ns].end();it++){
if(!n.count(it->first)||n[it->first]>n[ns]+d[ns][it->first]){
n[it->first]=n[ns]+d[ns][it->first];
}
}
}
return n[g];
}
int main(){
for(int n,m;cin>>n>>m,n|m;){
string s,p,g;
cin>>s>>p>>g;
map<string,map<string,int> > d;
for(int i=0;i<m;i++){
string a,b;
int dd,t;
cin>>a>>b>>dd>>t;
d[a][b]=dd/40+t;
d[b][a]=dd/40+t;
}
cout<<dik(d,s,p)+dik(d,p,g)<<endl;
}
return 0;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
Ilya got tired of sports programming, left university and got a job in the subway. He was given the task to determine the escalator load factor.
Let's assume that n people stand in the queue for the escalator. At each second one of the two following possibilities takes place: either the first person in the queue enters the escalator with probability p, or the first person in the queue doesn't move with probability (1 - p), paralyzed by his fear of escalators and making the whole queue wait behind him.
Formally speaking, the i-th person in the queue cannot enter the escalator until people with indices from 1 to i - 1 inclusive enter it. In one second only one person can enter the escalator. The escalator is infinite, so if a person enters it, he never leaves it, that is he will be standing on the escalator at any following second. Ilya needs to count the expected value of the number of people standing on the escalator after t seconds.
Your task is to help him solve this complicated task.
Input
The first line of the input contains three numbers n, p, t (1 β€ n, t β€ 2000, 0 β€ p β€ 1). Numbers n and t are integers, number p is real, given with exactly two digits after the decimal point.
Output
Print a single real number β the expected number of people who will be standing on the escalator after t seconds. The absolute or relative error mustn't exceed 10 - 6.
Examples
Input
1 0.50 1
Output
0.5
Input
1 0.50 4
Output
0.9375
Input
4 0.20 2
Output
0.4
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
double dp[2004][2004];
int main() {
int n, t;
double p, ans = 0.0000000;
cin >> n >> p >> t;
dp[0][0] = 1.000000000;
for (int i = 1; i <= t; ++i) dp[i][0] = dp[i - 1][0] * (1.0000000 - p);
for (int i = 1; i <= max(n, t); ++i) dp[0][i] = 0.000000000;
for (int i = 1; i <= t; ++i) {
for (int j = 1; j <= t; ++j) {
dp[i][j] = dp[i - 1][j - 1] * p + dp[i - 1][j] * (1.000000000 - p);
}
}
for (int i = 1; i <= t; ++i) ans += min(i, n) * dp[t][i];
printf("%.9lf\n", ans);
return 0;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
The Quarkgo Empire Expeditionary Force is an evil organization that plans to invade the Earth. In keeping with the tradition of the invaders, they continued to send monsters at a pace of one every week, targeting the area around Tokyo in Japan. However, each time, five warriors calling themselves the Human Squadron Earth Five appeared, and the monster who was rampaging in the city was easily defeated.
Walzard Thru (Earth name: Genmasa) is a female executive of the Quarkgo Empire Expeditionary Force who is seriously worried about such a situation. She had a headache under a commander who wouldn't learn anything from her weekly defeat, or a genius scientist who repeated some misplaced inventions.
Meanwhile, the next operation was decided to send the blood-sucking monster Dracula to Japan. Dracula is a terrifying monster who turns a blood-sucking human into Dracula. Humans who have been sucked by Dracula also suck the blood of other humans to increase their fellow Dracula. In this way, the strategy is to fill the entire earth with Dracula.
Upon hearing this, Walzard soon realized. This strategy is different from the usual sequel strategy such as taking over a kindergarten bus. It's rare for that bad commander to have devised it, and it has the potential to really conquer the Earth.
The momentum of the game is terrifying. Dracula, who landed on the ground, quickly increased the number of friends. If we went on like this, the invasion of the earth seemed to be just a stone's throw away. However, at that moment, a strong and unpleasant premonition ran through Walzard's mind. No way, if this monster, the original is defeated, his friends will not be wiped out, right?
When I asked the scientist who designed and developed Dracula in a hurry, he was still worried about Walzard. It is designed so that when the original Dracula is destroyed, all humans who have sucked blood will return to their original state. Don't be foolish developer. Why did you add such an extra function!
Walzard jumped to the developer and decided to kick his knee, and immediately started the original recovery work. No matter how much the original and the fake look exactly the same, if nothing is done, it is visible that the rushed Earth Five will see through the original for some reason and be defeated.
According to the developers, all Draculaized humans weigh the same, but the original Dracula is a little heavier. Then you should be able to find the original by using only the balance. You must find and retrieve the original Dracula as soon as possible before the Earth Five appears.
Input
N
The integer N (2 β€ N β€ 2,000,000,000) is written on the first line of the input. This represents the total number of Draculas, both original and fake.
Output
In the worst case, how many times is it enough to use the balance to find one original from the N Draculas using the balance? Output the minimum value. However, comparing the weights of several Draculas placed on the left and right plates of the balance is counted as one time.
Examples
Input
8
Output
2
Input
30
Output
4
Input
2000000000
Output
20
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(){
int N;
scanf("%d", &N);
printf("%d\n", (int)ceil(log(N) / log(3)));
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
Maria participates in a bicycle race.
The speedway takes place on the shores of Lake Lucerne, just repeating its contour. As you know, the lake shore consists only of straight sections, directed to the north, south, east or west.
Let's introduce a system of coordinates, directing the Ox axis from west to east, and the Oy axis from south to north. As a starting position of the race the southernmost point of the track is selected (and if there are several such points, the most western among them). The participants start the race, moving to the north. At all straight sections of the track, the participants travel in one of the four directions (north, south, east or west) and change the direction of movement only in bends between the straight sections. The participants, of course, never turn back, that is, they do not change the direction of movement from north to south or from east to west (or vice versa).
Maria is still young, so she does not feel confident at some turns. Namely, Maria feels insecure if at a failed or untimely turn, she gets into the water. In other words, Maria considers the turn dangerous if she immediately gets into the water if it is ignored.
Help Maria get ready for the competition β determine the number of dangerous turns on the track.
Input
The first line of the input contains an integer n (4 β€ n β€ 1000) β the number of straight sections of the track.
The following (n + 1)-th line contains pairs of integers (xi, yi) ( - 10 000 β€ xi, yi β€ 10 000). The first of these points is the starting position. The i-th straight section of the track begins at the point (xi, yi) and ends at the point (xi + 1, yi + 1).
It is guaranteed that:
* the first straight section is directed to the north;
* the southernmost (and if there are several, then the most western of among them) point of the track is the first point;
* the last point coincides with the first one (i.e., the start position);
* any pair of straight sections of the track has no shared points (except for the neighboring ones, they share exactly one point);
* no pair of points (except for the first and last one) is the same;
* no two adjacent straight sections are directed in the same direction or in opposite directions.
Output
Print a single integer β the number of dangerous turns on the track.
Examples
Input
6
0 0
0 1
1 1
1 2
2 2
2 0
0 0
Output
1
Input
16
1 1
1 5
3 5
3 7
2 7
2 9
6 9
6 7
5 7
5 3
4 3
4 4
3 4
3 2
5 2
5 1
1 1
Output
6
Note
The first sample corresponds to the picture:
<image>
The picture shows that you can get in the water under unfortunate circumstances only at turn at the point (1, 1). Thus, the answer is 1.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e3 + 3;
const int MAXABSXY = 1e4 + 4;
int n;
int x[MAXN], y[MAXN];
void solve() {
int ans = 0;
for (int i = 1; i <= n; ++i) {
int ldir, dir;
if (x[i - 2 >= 0 ? i - 2 : n] == x[i - 1]) {
if (y[i - 2 >= 0 ? i - 2 : n] < y[i - 1])
ldir = 0;
else
ldir = 1;
} else {
if (x[i - 2 >= 0 ? i - 2 : n] < x[i - 1])
ldir = 2;
else
ldir = 3;
}
if (x[i - 1] == x[i]) {
if (y[i - 1] < y[i])
dir = 0;
else
dir = 1;
} else {
if (x[i - 1] < x[i])
dir = 2;
else
dir = 3;
}
if (ldir == 0 && dir == 3) ++ans;
if (ldir == 1 && dir == 2) ++ans;
if (ldir == 2 && dir == 0) ++ans;
if (ldir == 3 && dir == 1) ++ans;
}
printf("%d\n", ans);
}
int main() {
scanf("%d", &n);
for (int i = 0; i <= n; ++i) scanf("%d%d", x + i, y + i);
solve();
return 0;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
In "Takahashi-ya", a ramen restaurant, basically they have one menu: "ramen", but N kinds of toppings are also offered. When a customer orders a bowl of ramen, for each kind of topping, he/she can choose whether to put it on top of his/her ramen or not. There is no limit on the number of toppings, and it is allowed to have all kinds of toppings or no topping at all. That is, considering the combination of the toppings, 2^N types of ramen can be ordered.
Akaki entered Takahashi-ya. She is thinking of ordering some bowls of ramen that satisfy both of the following two conditions:
* Do not order multiple bowls of ramen with the exactly same set of toppings.
* Each of the N kinds of toppings is on two or more bowls of ramen ordered.
You are given N and a prime number M. Find the number of the sets of bowls of ramen that satisfy these conditions, disregarding order, modulo M. Since she is in extreme hunger, ordering any number of bowls of ramen is fine.
Constraints
* 2 \leq N \leq 3000
* 10^8 \leq M \leq 10^9 + 9
* N is an integer.
* M is a prime number.
Input
Input is given from Standard Input in the following format:
N M
Output
Print the number of the sets of bowls of ramen that satisfy the conditions, disregarding order, modulo M.
Examples
Input
2 1000000007
Output
2
Input
3 1000000009
Output
118
Input
50 111111113
Output
1456748
Input
3000 123456791
Output
16369789
### Response
```cpp
#include <iostream>
using namespace std;
int N, M, fact[3009], inv[3009], factinv[3009], dp[3009][3009], pw[9000009], fermat[3009];
int main() {
cin >> N >> M;
fact[0] = 1;
for (int i = 1; i <= N; i++) fact[i] = 1LL * fact[i - 1] * i % M;
inv[1] = 1;
for (int i = 2; i <= N; i++) inv[i] = 1LL * inv[M % i] * (M - M / i) % M;
factinv[0] = 1;
for (int i = 1; i <= N; i++) factinv[i] = 1LL * inv[i] * factinv[i - 1] % M;
pw[0] = 1;
for (int i = 1; i <= N * N; i++) pw[i] = 2 * pw[i - 1] % M;
fermat[0] = 2;
for (int i = 1; i <= N; i++) fermat[i] = 1LL * fermat[i - 1] * fermat[i - 1] % M;
dp[0][0] = 1;
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= i; j++) {
dp[i][j] = (dp[i - 1][j - 1] + 1LL * j * dp[i - 1][j]) % M;
}
}
int ret = 0;
for (int i = 0; i <= N; i++) {
int val = 1LL * fact[N] * factinv[i] % M * factinv[N - i] % M * fermat[N - i] % M;
if (i & 1) val = (val == 0 ? 0 : M - val);
for (int j = 0; j <= i; j++) {
ret = (ret + 1LL * val % M * dp[i][j] % M * pw[(N - i) * j]) % M;
ret = (ret + 1LL * (j + 1) * val % M * dp[i][j + 1] % M * pw[(N - i) * j]) % M;
}
}
cout << ret << "\n";
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
You have successfully completed your studies and are preparing to move from near Komaba to near Hongo. As I was organizing my house, I found a lot of lottery tickets I bought last year. After confirming the exchange deadline, I have to cash in by tomorrow, but it is troublesome to go to the lottery counter for a small amount of money because I am not ready to move at all. So you decide to find out how much you can win.
The lottery consists of eight digits. The winning number is also composed of 8 digits and a number and'*', and if the lottery you have and the number part match, the winning money will be paid according to the winning number.
For example, if the lottery number you have is "12345678", you will win if the winning number is "******* 8" or "**** 5678", but the winning number is "**". If it is ** 4678 ", you will not win. There can be multiple winning numbers, and the winnings will be paid independently for each. However, the winning numbers are chosen so that one lottery does not win more than one winning number. For example, if there are two winning numbers, "******* 8" and "**** 5678", "12345678" will win both, so such a winning number will be selected. There is no one to be done.
Your job is to write a program that outputs how much winning money you will get for the lottery number you have and the lottery winning number given as input.
Notes on Test Cases
Multiple datasets are given in the above input format. Create a program that outputs each data set in the above output format.
When n is 0, it indicates the end of input.
<!-
Input
The input is given in the following format.
n m
N1 M1
...
Nn Mn
B1
...
Bm
In the first line, the number of winning numbers n (1 β€ n β€ 100) and the number of lottery tickets in possession m (1 β€ m β€ 1000) are given as integers.
In the next n lines, each line is given a winning number Ni and a winnings Mi (1 β€ Mi β€ 1000000). Winnings are integers. The format of the winning number is as described in the question text.
The next m lines will give you the number of the lottery you have.
Output
Output the total amount of winnings.
Examples
Input
3 3
*******1 100
******22 1000
11111112 1000000
01203291
02382022
11111111
10 10
****3228 149416
****3992 198635
****4286 77783
****4843 225244
***49835 231046
***59393 379996
*5763748 437345
*6726222 58054
*8117882 16375
*9244339 537727
77885716
96726222
26971031
66652868
89599648
37772338
64679621
65479161
92959393
57855682
0 0
Output
1200
438050
Input
3 3
*******1 100
******22 1000
11111112 1000000
01203291
02382022
11111111
Output
1200
Input
10 10
****3228 149416
****3992 198635
****4286 77783
****4843 225244
***49835 231046
***59393 379996
*5763748 437345
*6726222 58054
*8117882 16375
*9244339 537727
77885716
96726222
26971031
66652868
89599648
37772338
64679621
65479161
92959393
57855682
Output
438050
### Response
```cpp
#include <algorithm>
#include <cstdlib>
#include <iostream>
#include <utility>
#include <vector>
using namespace std;
bool match(const string &number, const string &lottery) {
for(unsigned i = 0; i < number.size(); ++i) {
if(number[i] != '*' && number[i] != lottery[i]) {
return false;
}
}
return true;
}
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
for(int n, m; cin >> n >> m && n;) {
vector<pair<int, string>> winning_numbers(n);
for(auto &e : winning_numbers) cin >> e.second >> e.first;
sort(winning_numbers.rbegin(), winning_numbers.rend());
int ans = 0;
while(m--) {
string lottery;
cin >> lottery;
for(auto &e : winning_numbers) {
if(match(e.second, lottery)) {
ans += e.first;
break;
}
}
}
cout << ans << endl;
}
return EXIT_SUCCESS;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
Your task is to write a program of a simple dictionary which implements the following instructions:
* insert str: insert a string str in to the dictionary
* find str: if the distionary contains str, then print 'yes', otherwise print 'no'
Notes
Template in C
Constraints
* A string consists of 'A', 'C', 'G', or 'T'
* 1 β€ length of a string β€ 12
* n β€ 1000000
Input
In the first line n, the number of instructions is given. In the following n lines, n instructions are given in the above mentioned format.
Output
Print yes or no for each find instruction in a line.
Examples
Input
5
insert A
insert T
insert C
find G
find A
Output
no
yes
Input
13
insert AAA
insert AAC
insert AGA
insert AGG
insert TTT
find AAA
find CCC
find CCC
insert CCC
find CCC
insert T
find TTT
find T
Output
yes
no
no
yes
yes
yes
### Response
```cpp
#include <iostream>
#include <map>
#include <string>
using namespace std;
int main(){
int n;
map<string, bool> mp;
cin >> n;
for(int i = 0; i < n; i++){
string s1, s2;
cin >> s1 >> s2;
if(s1 == "insert") mp[(s2)] = true;
else{
if(mp[(s2)]) cout << "yes" << endl;
else cout << "no" << endl;
}
}
return 0;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
You are given strings s and t. Find one longest string that is a subsequence of both s and t.
Constraints
* s and t are strings consisting of lowercase English letters.
* 1 \leq |s|, |t| \leq 3000
Input
Input is given from Standard Input in the following format:
s
t
Output
Print one longest string that is a subsequence of both s and t. If there are multiple such strings, any of them will be accepted.
Examples
Input
axyb
abyxb
Output
axb
Input
aa
xayaz
Output
aa
Input
a
z
Output
Input
abracadabra
avadakedavra
Output
aaadara
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e3+10;
char a[maxn],b[maxn];
int dp[maxn][maxn];
int main() {
scanf("%s",a+1);
scanf("%s",b+1);
int lena = strlen(a+1);
int lenb = strlen(b+1);
for(int i = lena;i >= 1;i--) {
for(int j = lenb;j >= 1;j--) {
if(a[i] == b[j])
dp[i][j] = dp[i+1][j+1] +1;
else
dp[i][j] = max(dp[i+1][j],dp[i][j+1]);
}
}
int l = 1,r = 1;
while(l <= lena && r <= lenb) {
if(a[l] == b[r]) {
cout<<a[l];
l++;
r++;
}
else if(dp[l][r] == dp[l+1][r]) l++;
else r++;
}
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
Vasya has found a piece of paper with an array written on it. The array consists of n integers a1, a2, ..., an. Vasya noticed that the following condition holds for the array ai β€ ai + 1 β€ 2Β·ai for any positive integer i (i < n).
Vasya wants to add either a "+" or a "-" before each number of array. Thus, Vasya will get an expression consisting of n summands. The value of the resulting expression is the sum of all its elements. The task is to add signs "+" and "-" before each number so that the value of expression s meets the limits 0 β€ s β€ a1. Print a sequence of signs "+" and "-", satisfying the given limits. It is guaranteed that the solution for the problem exists.
Input
The first line contains integer n (1 β€ n β€ 105) β the size of the array. The second line contains space-separated integers a1, a2, ..., an (0 β€ ai β€ 109) β the original array.
It is guaranteed that the condition ai β€ ai + 1 β€ 2Β·ai fulfills for any positive integer i (i < n).
Output
In a single line print the sequence of n characters "+" and "-", where the i-th character is the sign that is placed in front of number ai. The value of the resulting expression s must fit into the limits 0 β€ s β€ a1. If there are multiple solutions, you are allowed to print any of them.
Examples
Input
4
1 2 3 5
Output
+++-
Input
3
3 3 5
Output
++-
### Response
```cpp
#include <bits/stdc++.h>
int main() {
int n;
scanf("%d", &n);
int i, b[n];
int sum = 0;
char out[n];
for (i = 0; i < n; i++) {
scanf("%d", &b[i]);
}
for (i = n - 1; i >= 0; i--) {
if (sum <= 0) {
sum = sum + b[i];
out[i] = '+';
} else {
sum -= b[i];
out[i] = '-';
}
}
for (i = 0; i < n; i++) {
if (sum < 0) {
if (out[i] == '+')
out[i] = '-';
else if (out[i] == '-')
out[i] = '+';
}
printf("%c", out[i]);
}
printf("\n");
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
Iahub accidentally discovered a secret lab. He found there n devices ordered in a line, numbered from 1 to n from left to right. Each device i (1 β€ i β€ n) can create either ai units of matter or ai units of antimatter.
Iahub wants to choose some contiguous subarray of devices in the lab, specify the production mode for each of them (produce matter or antimatter) and finally take a photo of it. However he will be successful only if the amounts of matter and antimatter produced in the selected subarray will be the same (otherwise there would be overflowing matter or antimatter in the photo).
You are requested to compute the number of different ways Iahub can successful take a photo. A photo is different than another if it represents another subarray, or if at least one device of the subarray is set to produce matter in one of the photos and antimatter in the other one.
Input
The first line contains an integer n (1 β€ n β€ 1000). The second line contains n integers a1, a2, ..., an (1 β€ ai β€ 1000).
The sum a1 + a2 + ... + an will be less than or equal to 10000.
Output
Output a single integer, the number of ways Iahub can take a photo, modulo 1000000007 (109 + 7).
Examples
Input
4
1 1 1 1
Output
12
Note
The possible photos are [1+, 2-], [1-, 2+], [2+, 3-], [2-, 3+], [3+, 4-], [3-, 4+], [1+, 2+, 3-, 4-], [1+, 2-, 3+, 4-], [1+, 2-, 3-, 4+], [1-, 2+, 3+, 4-], [1-, 2+, 3-, 4+] and [1-, 2-, 3+, 4+], where "i+" means that the i-th element produces matter, and "i-" means that the i-th element produces antimatter.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007, MAXN = 1000, MAXSUM = 10000;
int dp[MAXN][(2 * MAXSUM) + 1], a[MAXN], n, i, j, sol;
int main() {
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%d", &a[i]);
dp[0][MAXSUM + a[0]]++;
dp[0][MAXSUM - a[0]]++;
sol = ((sol + dp[0][MAXSUM]) % MOD);
for (i = 1; i < n; i++) {
for (j = (-MAXSUM); j <= MAXSUM; j++)
dp[i][j + MAXSUM] =
((dp[i - 1][j + (MAXSUM - a[i])] + dp[i - 1][j + (MAXSUM + a[i])] +
(a[i] == (abs(j)))) %
MOD);
sol = ((sol + dp[i][MAXSUM]) % MOD);
}
printf("%d\n", sol);
return 0;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
We will consider the numbers a and b as adjacent if they differ by exactly one, that is, |a-b|=1.
We will consider cells of a square matrix n Γ n as adjacent if they have a common side, that is, for cell (r, c) cells (r, c-1), (r, c+1), (r-1, c) and (r+1, c) are adjacent to it.
For a given number n, construct a square matrix n Γ n such that:
* Each integer from 1 to n^2 occurs in this matrix exactly once;
* If (r_1, c_1) and (r_2, c_2) are adjacent cells, then the numbers written in them must not be adjacent.
Input
The first line contains one integer t (1 β€ t β€ 100). Then t test cases follow.
Each test case is characterized by one integer n (1 β€ n β€ 100).
Output
For each test case, output:
* -1, if the required matrix does not exist;
* the required matrix, otherwise (any such matrix if many of them exist).
The matrix should be outputted as n lines, where each line contains n integers.
Example
Input
3
1
2
3
Output
1
-1
2 9 7
4 6 3
1 8 5
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
#define ll long long int
#define Sort(v) sort(v.begin(),v.end())
#define Fast ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
int main()
{
Fast
ll t,i,j,k;cin>>t;
while(t--)
{
ll n;
cin>>n;
if(n==1)cout<<1<<endl;else if(n==2)cout<<-1<<endl;
else{
ll x=n*n;
if(x%2!=0){
for(i=1;i<=x;i+=2)cout<<i<<" ";
for(i=2;i<x;i+=2)cout<<i<<" ";
}
else if(x%2==0){
for(i=1;i<x;i+=2)cout<<i<<" ";
for(i=2;i<=x;i+=2)cout<<i<<" ";
}
}
}
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
problem
AOR Ika-chan, who loves feasts, defined "the number of feasts". A feast number is a natural number that includes "$ 51-3 $" in $ 10 $ decimal notation.
$? $ Can be any number from $ 0 $ to $ 9 $.
Find the number of feasts out of the natural numbers below $ N $.
input
$ N $
output
Output the number of feasts in one line. Also, output a line break at the end.
Example
Input
5124
Output
3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
#define INF_LL (int64)1e18
#define INF (int32)1e9
#define REP(i, n) for(int64 i = 0;i < (n);i++)
#define FOR(i, a, b) for(int64 i = (a);i < (b);i++)
#define all(x) x.begin(),x.end()
#define fs first
#define sc second
using int32 = int_fast32_t;
using uint32 = uint_fast32_t;
using int64 = int_fast64_t;
using uint64 = uint_fast64_t;
using PII = pair<int32, int32>;
using PLL = pair<int64, int64>;
const double eps = 1e-10;
template<typename A, typename B>inline void chmin(A &a, B b){if(a > b) a = b;}
template<typename A, typename B>inline void chmax(A &a, B b){if(a < b) a = b;}
string s;
int64 dp[20][2][1000][2] = {};
int64 dfs(int32 k = 0, bool tight = 1, int32 lst = 0, int32 ok = 0){
if(k == s.size()) return ok;
int32 lim = (tight ? s[k]+1 : 10);
int64 &res = dp[k][tight][lst][ok];
if(~res) return res;
res = 0;
REP(i, lim){
int32 nxt = (lst*10+i)%1000;
if(!ok && 510 <= lst && lst < 520 && i == 3)
res += dfs(k+1, tight && i == (lim-1), nxt, 1);
else
res += dfs(k+1, tight && i == (lim-1), nxt, ok);
}
return res;
}
int main(void){
cin >> s;
REP(i, s.size()) s[i] -= '0';
memset(dp, -1, sizeof dp);
cout << dfs() << endl;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Sereja is a coder and he likes to take part in Codesorfes rounds. However, Uzhland doesn't have good internet connection, so Sereja sometimes skips rounds.
Codesorfes has rounds of two types: Div1 (for advanced coders) and Div2 (for beginner coders). Two rounds, Div1 and Div2, can go simultaneously, (Div1 round cannot be held without Div2) in all other cases the rounds don't overlap in time. Each round has a unique identifier β a positive integer. The rounds are sequentially (without gaps) numbered with identifiers by the starting time of the round. The identifiers of rounds that are run simultaneously are different by one, also the identifier of the Div1 round is always greater.
Sereja is a beginner coder, so he can take part only in rounds of Div2 type. At the moment he is taking part in a Div2 round, its identifier equals to x. Sereja remembers very well that he has taken part in exactly k rounds before this round. Also, he remembers all identifiers of the rounds he has taken part in and all identifiers of the rounds that went simultaneously with them. Sereja doesn't remember anything about the rounds he missed.
Sereja is wondering: what minimum and what maximum number of Div2 rounds could he have missed? Help him find these two numbers.
Input
The first line contains two integers: x (1 β€ x β€ 4000) β the round Sereja is taking part in today, and k (0 β€ k < 4000) β the number of rounds he took part in.
Next k lines contain the descriptions of the rounds that Sereja took part in before. If Sereja took part in one of two simultaneous rounds, the corresponding line looks like: "1 num2 num1" (where num2 is the identifier of this Div2 round, num1 is the identifier of the Div1 round). It is guaranteed that num1 - num2 = 1. If Sereja took part in a usual Div2 round, then the corresponding line looks like: "2 num" (where num is the identifier of this Div2 round). It is guaranteed that the identifiers of all given rounds are less than x.
Output
Print in a single line two integers β the minimum and the maximum number of rounds that Sereja could have missed.
Examples
Input
3 2
2 1
2 2
Output
0 0
Input
9 3
1 2 3
2 8
1 4 5
Output
2 3
Input
10 0
Output
5 9
Note
In the second sample we have unused identifiers of rounds 1, 6, 7. The minimum number of rounds Sereja could have missed equals to 2. In this case, the round with the identifier 1 will be a usual Div2 round and the round with identifier 6 will be synchronous with the Div1 round.
The maximum number of rounds equals 3. In this case all unused identifiers belong to usual Div2 rounds.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void solv();
int main() { solv(); }
int a[100000];
void solv() {
int n, m;
cin >> n >> m;
while (m--) {
int x;
cin >> x;
if (x == 1) {
int a1, b;
cin >> a1 >> b;
a[a1] = 1;
a[b] = 1;
} else {
int x1;
cin >> x1;
a[x1] = 1;
}
}
int mx = 0;
for (int i = 1; i < n; i++) {
if (!a[i]) mx++;
}
int mn = 0;
for (int i = 1; i < n; i++) {
if (!a[i] && !a[i + 1]) {
mn += 1;
a[i + 1] = 1;
continue;
}
if (!a[i] && a[i + 1]) {
mn++;
}
}
cout << mn << ' ' << mx;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
Little girl Susie went shopping with her mom and she wondered how to improve service quality.
There are n people in the queue. For each person we know time ti needed to serve him. A person will be disappointed if the time he waits is more than the time needed to serve him. The time a person waits is the total time when all the people who stand in the queue in front of him are served. Susie thought that if we swap some people in the queue, then we can decrease the number of people who are disappointed.
Help Susie find out what is the maximum number of not disappointed people can be achieved by swapping people in the queue.
Input
The first line contains integer n (1 β€ n β€ 105).
The next line contains n integers ti (1 β€ ti β€ 109), separated by spaces.
Output
Print a single number β the maximum number of not disappointed people in the queue.
Examples
Input
5
15 2 1 5 3
Output
4
Note
Value 4 is achieved at such an arrangement, for example: 1, 2, 3, 5, 15. Thus, you can make everything feel not disappointed except for the person with time 5.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int i, t[n];
for (i = 0; i < n; i++) cin >> t[i];
sort(t, t + n);
int cnt = 1;
int wait = t[0];
i = 1;
while (i < n) {
if (wait <= t[i]) {
cnt++;
wait += t[i];
i++;
} else
i++;
}
cout << cnt;
return 0;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
You are given a problemset consisting of n problems. The difficulty of the i-th problem is a_i. It is guaranteed that all difficulties are distinct and are given in the increasing order.
You have to assemble the contest which consists of some problems of the given problemset. In other words, the contest you have to assemble should be a subset of problems (not necessary consecutive) of the given problemset. There is only one condition that should be satisfied: for each problem but the hardest one (the problem with the maximum difficulty) there should be a problem with the difficulty greater than the difficulty of this problem but not greater than twice the difficulty of this problem. In other words, let a_{i_1}, a_{i_2}, ..., a_{i_p} be the difficulties of the selected problems in increasing order. Then for each j from 1 to p-1 a_{i_{j + 1}} β€ a_{i_j} β
2 should hold. It means that the contest consisting of only one problem is always valid.
Among all contests satisfying the condition above you have to assemble one with the maximum number of problems. Your task is to find this number of problems.
Input
The first line of the input contains one integer n (1 β€ n β€ 2 β
10^5) β the number of problems in the problemset.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 β€ a_i β€ 10^9) β difficulties of the problems. It is guaranteed that difficulties of the problems are distinct and are given in the increasing order.
Output
Print a single integer β maximum number of problems in the contest satisfying the condition in the problem statement.
Examples
Input
10
1 2 5 6 7 10 21 23 24 49
Output
4
Input
5
2 10 50 110 250
Output
1
Input
6
4 7 12 100 150 199
Output
3
Note
Description of the first example: there are 10 valid contests consisting of 1 problem, 10 valid contests consisting of 2 problems ([1, 2], [5, 6], [5, 7], [5, 10], [6, 7], [6, 10], [7, 10], [21, 23], [21, 24], [23, 24]), 5 valid contests consisting of 3 problems ([5, 6, 7], [5, 6, 10], [5, 7, 10], [6, 7, 10], [21, 23, 24]) and a single valid contest consisting of 4 problems ([5, 6, 7, 10]).
In the second example all the valid contests consist of 1 problem.
In the third example are two contests consisting of 3 problems: [4, 7, 12] and [100, 150, 199].
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
bool isPrime[1000005] = {false};
vector<long long> prm;
vector<long long> SPF(1000005);
void sieve() {
isPrime[1] = isPrime[0] = 0;
long long i;
for (i = 2; i < 1000005; ++i) isPrime[i] = 1;
for (i = 2; i * i < 1000005; ++i) {
if (isPrime[i]) {
for (long long j = i * i; j < 1000005; j += i) isPrime[j] = 0;
}
}
if (!prm.empty()) prm.clear();
for (i = 2; i < 1000005; ++i) {
if (isPrime[i]) prm.push_back(i);
}
}
bool flip(bool f) {
if (f) return 0;
return 1;
}
long long fastPower(long long a, long long b) {
if (b == 0) return 1;
long long prod = 1;
while (b > 0) {
if (b & 1) prod = prod * a;
b = b >> 1;
a = a * a;
}
return prod;
}
long long fact(long long n) {
long long res = 1;
for (long long i = 2; i <= n; i++) {
res *= i;
}
return res;
}
long long nCr(long long n, long long r) {
return (long double)fact(n) / (long double)(fact(r) * fact(n - r));
}
void printa(bool f) {
if (f)
cout << "YES"
<< "\n";
else
cout << "NO"
<< "\n";
}
long long bs(vector<long long> &a, long long l, long long r, long long x) {
long long m;
while (l <= r) {
m = l - (r + l) / 2;
if (x * 2 <= a[m])
return m;
else
r = m - 1;
}
return -1;
}
void solve() {
long long n, i;
cin >> n;
vector<long long> a(n);
for (i = 0; i < n; ++i) cin >> a[i];
long long ans = 0;
for (i = 0; i < n; ++i) {
long long j = i;
while (j + 1 < n && a[j] * 2 >= a[j + 1]) ++j;
ans = max(ans, j - i + 1);
i = j;
}
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int tc = 1;
while (tc--) {
solve();
}
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
You are given two arrays of integers a_1,β¦,a_n and b_1,β¦,b_m.
Your task is to find a non-empty array c_1,β¦,c_k that is a subsequence of a_1,β¦,a_n, and also a subsequence of b_1,β¦,b_m. If there are multiple answers, find one of the smallest possible length. If there are still multiple of the smallest possible length, find any. If there are no such arrays, you should report about it.
A sequence a is a subsequence of a sequence b if a can be obtained from b by deletion of several (possibly, zero) elements. For example, [3,1] is a subsequence of [3,2,1] and [4,3,1], but not a subsequence of [1,3,3,7] and [3,10,4].
Input
The first line contains a single integer t (1β€ tβ€ 1000) β the number of test cases. Next 3t lines contain descriptions of test cases.
The first line of each test case contains two integers n and m (1β€ n,mβ€ 1000) β the lengths of the two arrays.
The second line of each test case contains n integers a_1,β¦,a_n (1β€ a_iβ€ 1000) β the elements of the first array.
The third line of each test case contains m integers b_1,β¦,b_m (1β€ b_iβ€ 1000) β the elements of the second array.
It is guaranteed that the sum of n and the sum of m across all test cases does not exceed 1000 (β_{i=1}^t n_i, β_{i=1}^t m_iβ€ 1000).
Output
For each test case, output "YES" if a solution exists, or "NO" otherwise.
If the answer is "YES", on the next line output an integer k (1β€ kβ€ 1000) β the length of the array, followed by k integers c_1,β¦,c_k (1β€ c_iβ€ 1000) β the elements of the array.
If there are multiple solutions with the smallest possible k, output any.
Example
Input
5
4 5
10 8 6 4
1 2 3 4 5
1 1
3
3
1 1
3
2
5 3
1000 2 2 2 3
3 1 5
5 5
1 2 3 4 5
1 2 3 4 5
Output
YES
1 4
YES
1 3
NO
YES
1 3
YES
1 2
Note
In the first test case, [4] is a subsequence of [10, 8, 6, 4] and [1, 2, 3, 4, 5]. This array has length 1, it is the smallest possible length of a subsequence of both a and b.
In the third test case, no non-empty subsequences of both [3] and [2] exist, so the answer is "NO".
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
istream& operator>>(istream& in, pair<T1, T2>& a) {
in >> a.first >> a.second;
return in;
}
template <typename T1, typename T2>
ostream& operator<<(ostream& out, pair<T1, T2> a) {
out << a.first << " " << a.second;
return out;
}
template <typename T, typename T1>
T amax(T& a, T1 b) {
if (b > a) a = b;
return a;
}
template <typename T, typename T1>
T amin(T& a, T1 b) {
if (b < a) a = b;
return a;
}
const long long INF = 1e18;
const int32_t M = 1e9 + 7;
const int32_t MM = 998244353;
const int N = 55;
void solve() {
long long int m, n, count = 0;
cin >> m >> n;
long long int mini = min(m, n);
long long int arr[m], arr2[n], arr3[mini];
for (int i = 0; i < m; i++) {
cin >> arr[i];
}
for (int i = 0; i < n; i++) {
cin >> arr2[i];
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (arr[i] == arr2[j]) {
arr3[count] = arr[i];
count++;
break;
}
}
if (count > 0) break;
}
if (count > 0) {
cout << "YES" << endl;
cout << count << " ";
for (int i = 0; i < count; i++) cout << arr3[i] << " ";
cout << endl;
} else
cout << "NO" << endl;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
Given are integers N and X. For each integer k between 0 and X (inclusive), find the answer to the following question, then compute the sum of all those answers, modulo 998244353.
* Let us repeat the following operation on the integer k. Operation: if the integer is currently odd, subtract 1 from it and divide it by 2; otherwise, divide it by 2 and add 2^{N-1} to it. How many operations need to be performed until k returns to its original value? (The answer is considered to be 0 if k never returns to its original value.)
Constraints
* 1 \leq N \leq 2\times 10^5
* 0 \leq X < 2^N
* X is given in binary and has exactly N digits. (In case X has less than N digits, it is given with leading zeroes.)
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
X
Output
Print the sum of the answers to the questions for the integers between 0 and X (inclusive), modulo 998244353.
Examples
Input
3
111
Output
40
Input
6
110101
Output
616
Input
30
001110011011011101010111011100
Output
549320998
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define f(i, x, n) for (int i = x; i < (int)(n); ++i)
int const N = 400000, md = 998244353;
int dp[N + 1], n, n2, p2[N + 1];
bool ok[N + 1];
char s[N], z[N];
void ad(int &x, int y) { if ((x += y) >= md)x -= md; }
void sb(int &x, int y) { if ((x -= y) < 0 )x += md; }
bool fl(int x){
f(i, x, n)z[i] = z[i - x] ^ 1;
f(i, 0, n)if (z[i] < s[i])return true;
else if (z[i] > s[i])return false;
return true;
}
void go(int x){
x >>= 1;
f(i, 0, x){
if (s[i] == '1')ad(dp[x << 1], p2[x - i - 1]);
z[i] = s[i];
}
if (fl(x))ad(dp[x << 1], 1);
}
int main(){
scanf("%d%s", &n, s);
n2 = n << 1;
p2[0] = 1;
f(i, 1, n2 + 1)ad(p2[i] = p2[i - 1], p2[i - 1]);
f(i, 1, n2 + 1)if (n % i && n2 % i == 0)ok[i] = true;
f(i, 1, n2 + 1)if (ok[i])go(i);
f(i, 1, n2 + 1)if (ok[i])for (int j = i << 1; j <= n2; j += i)sb(dp[j], dp[i]);
int an = 0;
f(i, 1, n2 + 1)if (ok[i])ad(an, (ll)i * dp[i] % md);
printf("%d\n", an);
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
In one one-dimensional world there are n platforms. Platform with index k (platforms are numbered from 1) is a segment with coordinates [(k - 1)m, (k - 1)m + l], and l < m. Grasshopper Bob starts to jump along the platforms from point 0, with each jump he moves exactly d units right. Find out the coordinate of the point, where Bob will fall down. The grasshopper falls down, if he finds himself not on the platform, but if he finds himself on the edge of the platform, he doesn't fall down.
Input
The first input line contains 4 integer numbers n, d, m, l (1 β€ n, d, m, l β€ 106, l < m) β respectively: amount of platforms, length of the grasshopper Bob's jump, and numbers m and l needed to find coordinates of the k-th platform: [(k - 1)m, (k - 1)m + l].
Output
Output the coordinates of the point, where the grosshopper will fall down. Don't forget that if Bob finds himself on the platform edge, he doesn't fall down.
Examples
Input
2 2 5 3
Output
4
Input
5 4 11 8
Output
20
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, d, m, l;
long long int k;
long long int g;
fscanf(stdin, "%d%d%d%d", &n, &d, &m, &l);
for (k = 1, g = 0; k <= n; k++) {
if (g < ((k - 1) * m)) {
cout << g;
return 0;
} else if (g <= (((k - 1) * m) + l)) {
g += (((((k - 1) * m) + l) - g) / d) * d;
while (g <= (((k - 1) * m) + l)) g += d;
}
}
cout << g;
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
Little boy Petya loves stairs very much. But he is bored from simple going up and down them β he loves jumping over several stairs at a time. As he stands on some stair, he can either jump to the next one or jump over one or two stairs at a time. But some stairs are too dirty and Petya doesn't want to step on them.
Now Petya is on the first stair of the staircase, consisting of n stairs. He also knows the numbers of the dirty stairs of this staircase. Help Petya find out if he can jump through the entire staircase and reach the last stair number n without touching a dirty stair once.
One has to note that anyway Petya should step on the first and last stairs, so if the first or the last stair is dirty, then Petya cannot choose a path with clean steps only.
Input
The first line contains two integers n and m (1 β€ n β€ 109, 0 β€ m β€ 3000) β the number of stairs in the staircase and the number of dirty stairs, correspondingly. The second line contains m different space-separated integers d1, d2, ..., dm (1 β€ di β€ n) β the numbers of the dirty stairs (in an arbitrary order).
Output
Print "YES" if Petya can reach stair number n, stepping only on the clean stairs. Otherwise print "NO".
Examples
Input
10 5
2 4 8 3 6
Output
NO
Input
10 5
2 4 5 7 9
Output
YES
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
scanf("%d%d", &n, &m);
int A[3010];
for (int i = 0; i < m; i++) scanf("%d", &A[i]);
sort(A, A + m);
if (A[0] == 1 || A[m - 1] == n) {
printf("NO\n");
return 0;
}
bool valid = true;
for (int i = 0; i + 2 < m; i++)
if (A[i] + 1 == A[i + 1] && A[i + 1] + 1 == A[i + 2]) valid = false;
if (valid)
printf("YES\n");
else
printf("NO\n");
return 0;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
The life goes up and down, just like nice sequences. Sequence t1, t2, ..., tn is called nice if the following two conditions are satisfied:
* ti < ti + 1 for each odd i < n;
* ti > ti + 1 for each even i < n.
For example, sequences (2, 8), (1, 5, 1) and (2, 5, 1, 100, 99, 120) are nice, while (1, 1), (1, 2, 3) and (2, 5, 3, 2) are not.
Bear Limak has a sequence of positive integers t1, t2, ..., tn. This sequence is not nice now and Limak wants to fix it by a single swap. He is going to choose two indices i < j and swap elements ti and tj in order to get a nice sequence. Count the number of ways to do so. Two ways are considered different if indices of elements chosen for a swap are different.
Input
The first line of the input contains one integer n (2 β€ n β€ 150 000) β the length of the sequence.
The second line contains n integers t1, t2, ..., tn (1 β€ ti β€ 150 000) β the initial sequence. It's guaranteed that the given sequence is not nice.
Output
Print the number of ways to swap two elements exactly once in order to get a nice sequence.
Examples
Input
5
2 8 4 7 7
Output
2
Input
4
200 150 100 50
Output
1
Input
10
3 2 1 4 1 4 1 4 1 4
Output
8
Input
9
1 2 3 4 5 6 7 8 9
Output
0
Note
In the first sample, there are two ways to get a nice sequence with one swap:
1. Swap t2 = 8 with t4 = 7.
2. Swap t1 = 2 with t5 = 7.
In the second sample, there is only one way β Limak should swap t1 = 200 with t4 = 50.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-8;
const long long MOD = 1e9 + 7;
const long long INF = 1e18;
const long double PI = 3.1415926535897932384626433832795028841;
bool TST = 0;
long long powmod(long long a, long long b) {
long long res = 1;
a %= MOD;
for (; b; b >>= 1) {
if (b & 1) res = res * a % MOD;
a = a * a % MOD;
}
return res;
}
void Show(int *QQ, int N) {
if (not TST) {
return;
}
for (int x = 0; x < N; x++) {
cout << QQ[x];
if (x != N - 1) {
cout << ',';
}
}
cout << '\n';
}
void ShowLL(long long *QQ, int N) {
if (not TST) {
return;
}
for (int x = 0; x < N; x++) {
cout << QQ[x];
if (x != N - 1) {
cout << ',';
}
}
cout << '\n';
}
int n, T[150002];
int D[150002];
int EC[150002];
set<pair<int, int> > U;
int RR(int a, int b) {
if (a >= b) {
return 0;
}
return EC[((b - 1) + 1)] - EC[((a - 1) + 1)];
}
bool BackCheck(int i) {
if (i == 0) {
return 1;
}
if ((i - 1) % 2 == 1) {
return D[i - 1] > D[i];
}
return D[i - 1] < D[i];
}
bool FrontCheck(int i) {
if (i == n - 1) {
return 1;
}
if (i % 2 == 1) {
return D[i] > D[i + 1];
}
return D[i] < D[i + 1];
}
bool Errors(int i) { return (not BackCheck(i)) or (not FrontCheck(i)); }
void MARK(int x, int y) {
int a = min(x, y);
int b = max(x, y);
U.insert(pair<int, int>(a, b));
}
bool USED(int x, int y) {
int a = min(x, y);
int b = max(x, y);
if (U.find(pair<int, int>(a, b)) != U.end()) {
return true;
}
return false;
}
int swapCheck(int i) {
for (int x = 0; x < n; x++) {
D[x] = T[x];
}
int ways = 0;
for (int x = 0; x < n; x++) {
if (x == i) {
continue;
}
if (USED(x, i)) {
continue;
}
MARK(x, i);
swap(D[x], D[i]);
if (Errors(i) or Errors(x)) {
swap(D[x], D[i]);
continue;
}
int t1 = min(x, i);
int t2 = max(x, i);
int b1 = RR(0, t1 - 1);
int b2 = RR(t1 + 1, t2 - 1);
int b3 = RR(t2 + 1, n - 1);
if (b1 + b2 + b3 > 0) {
swap(D[x], D[i]);
continue;
}
ways++;
swap(D[x], D[i]);
}
return ways;
}
int main() {
scanf("%i", &n);
for (int x = 0; x < n; x++) {
scanf("%i", &T[x]);
}
EC[0] = 0;
for (int x = 0; x < n; x++) {
int errors = 0;
if (x % 2 == 0 and T[x] >= T[x + 1]) {
errors++;
}
if (x % 2 == 1 and T[x] <= T[x + 1]) {
errors++;
}
EC[x + 1] = EC[x] + errors;
}
if (EC[n - 1] > 4) {
printf("0\n");
return 0;
}
int ans = 0;
for (int i = 0; i < n; i++) {
if (i % 2 == 0 and T[i] >= T[i + 1]) {
ans += swapCheck(i);
ans += swapCheck(i + 1);
i++;
}
if (i % 2 == 1 and T[i] <= T[i + 1]) {
ans += swapCheck(i);
ans += swapCheck(i + 1);
i++;
}
}
printf("%i\n", ans);
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
Decimal numbers are a common notation system currently in use and use ten symbols 0, 1, 2, 3, 4, 5, 6, 7, 8, and 9 to represent all numbers.
Binary numbers are a popular notation in the computer world and use two symbols, 0 and 1, to represent all numbers.
Only the four numbers 0, 1, 2, and 3 are used in quaternary numbers. In quaternary numbers, when the number is incremented from 0, it will be carried to the next digit when it reaches 4. Therefore, the decimal number 4 is carried to the expression "10".
Decimal | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | ...
--- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |- ---
Binary | 0 | 1 | 10 | 11 | 100 | 101 | 110 | 111 | 1000 | 101 | 1010 | ...
Quadrant | 0 | 1 | 2 | 3 | 10 | 11 | 12 | 13 | 20 | 21 | 22 | ...
In Hawaii, fish and taro were counted between fingers in the old days, so it seems that they used quaternary numbers instead of decimal numbers.
Create a program that converts the integer n input in decimal to decimal and outputs it.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of -1. One integer n (0 β€ n β€ 1000000) is given on one row for each dataset.
The number of datasets does not exceed 2000.
Output
The result of conversion to quaternary number for each input data set is output on one line.
Example
Input
7
4
0
12
10
10000
-1
Output
13
10
0
30
22
2130100
### Response
```cpp
#include<iostream>
using namespace std;
void convert(int x){
if ( x == 0 ) return;
convert(x/4); cout << x%4;
}
int main(){
int n;
while( cin >> n && n >= 0 ) {
if ( n == 0 ) cout << 0 << endl;
else {
convert(n); cout << endl;
}
}
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
You are given an array of n integers: a_1, a_2, β¦, a_n. Your task is to find some non-zero integer d (-10^3 β€ d β€ 10^3) such that, after each number in the array is divided by d, the number of positive numbers that are presented in the array is greater than or equal to half of the array size (i.e., at least βn/2β). Note that those positive numbers do not need to be an integer (e.g., a 2.5 counts as a positive number). If there are multiple values of d that satisfy the condition, you may print any of them. In case that there is no such d, print a single integer 0.
Recall that β x β represents the smallest integer that is not less than x and that zero (0) is neither positive nor negative.
Input
The first line contains one integer n (1 β€ n β€ 100) β the number of elements in the array.
The second line contains n space-separated integers a_1, a_2, β¦, a_n (-10^3 β€ a_i β€ 10^3).
Output
Print one integer d (-10^3 β€ d β€ 10^3 and d β 0) that satisfies the given condition. If there are multiple values of d that satisfy the condition, you may print any of them. In case that there is no such d, print a single integer 0.
Examples
Input
5
10 0 -7 2 6
Output
4
Input
7
0 0 1 -1 0 0 2
Output
0
Note
In the first sample, n = 5, so we need at least β5/2β = 3 positive numbers after division. If d = 4, the array after division is [2.5, 0, -1.75, 0.5, 1.5], in which there are 3 positive numbers (namely: 2.5, 0.5, and 1.5).
In the second sample, there is no valid d, so 0 should be printed.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n, key, pos = 0, negative = 0;
cin >> t;
n = t;
while (t--) {
cin >> key;
if (key > 0)
pos++;
else if (key < 0)
negative++;
}
if ((n + 1) / 2 <= pos)
cout << 1 << endl;
else if ((n + 1) / 2 <= negative)
cout << -1 << endl;
else
cout << 0 << endl;
return 0;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
Several ages ago Berland was a kingdom. The King of Berland adored math. That's why, when he first visited one of his many palaces, he first of all paid attention to the floor in one hall. The floor was tiled with hexagonal tiles.
The hall also turned out hexagonal in its shape. The King walked along the perimeter of the hall and concluded that each of the six sides has a, b, c, a, b and c adjacent tiles, correspondingly.
To better visualize the situation, look at the picture showing a similar hexagon for a = 2, b = 3 and c = 4.
<image>
According to the legend, as the King of Berland obtained the values a, b and c, he almost immediately calculated the total number of tiles on the hall floor. Can you do the same?
Input
The first line contains three integers: a, b and c (2 β€ a, b, c β€ 1000).
Output
Print a single number β the total number of tiles on the hall floor.
Examples
Input
2 3 4
Output
18
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long a, b, c;
cin >> a >> b >> c;
cout << (a * b + b * c + c * a) - (a + b + c) + 1;
return;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
solve();
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Brave Ponta and his best friend, Brave Gonta, have come to Luida's bar in search of friends to embark on an epic adventure. There are many warriors, monks and wizards in the tavern who are itching to go on an adventure.
Gonta, who is kind-hearted, cared for Ponta and said, "You can choose your friends first."
On the other hand, don't worry about Ponta and Gonta. "No, you can choose first."
We continued to give in to each other, and finally Luida proposed: "Then, I'll divide the n registrants here with this" party division machine "so that the total fighting power of each party is as even as possible."
The task given to you is to create a program that is built into the partying machine.
This program inputs n integers and outputs the minimum difference between the total value of the integers contained in A and the total value of the integers contained in B when they are divided into two groups A and B. Must be.
Thanks to this machine, Ponta and Gonta got along well and went on an epic adventure ...
Input
Multiple datasets are given as input. Each dataset is given in the following format:
n (number of registrants: integer)
a1 a2 ... an (combat power of each registrant: blank-separated integer)
n is 20 or less, and each registrant's combat power does not exceed 1 million.
When n is 0, it is the end of input.
Output
Print the minimum value on one line for each dataset.
Example
Input
5
1 2 3 4 5
4
2 3 5 7
0
Output
1
1
### Response
```cpp
#include <iostream>
#include <sstream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <ctime>
#include <cstring>
#include <string>
#include <vector>
#include <stack>
#include <queue>
#include <deque>
#include <map>
#include <set>
#include <bitset>
#include <numeric>
#include <utility>
#include <iomanip>
#include <algorithm>
#include <functional>
using namespace std;
typedef long long ll;
typedef vector<int> vint;
typedef vector<long long> vll;
typedef pair<int,int> pint;
typedef pair<long long, long long> pll;
#define MP make_pair
#define PB push_back
#define ALL(s) (s).begin(),(s).end()
#define EACH(i, s) for (__typeof__((s).begin()) i = (s).begin(); i != (s).end(); ++i)
#define COUT(x) cout << #x << " = " << (x) << " (L" << __LINE__ << ")" << endl
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
template<class T1, class T2> ostream& operator << (ostream &s, pair<T1,T2> P)
{ return s << '<' << P.first << ", " << P.second << '>'; }
template<class T> ostream& operator << (ostream &s, vector<T> P)
{ for (int i = 0; i < P.size(); ++i) { if (i > 0) { s << " "; } s << P[i]; } return s; }
template<class T1, class T2> ostream& operator << (ostream &s, map<T1,T2> P)
{ EACH(it, P) { s << "<" << it->first << "->" << it->second << "> "; } return s; }
int n;
int a[25];
int main() {
while (cin >> n) {
if (n == 0) break;
int sum = 0;
for (int i = 0; i < n; ++i) {
cin >> a[i];
sum += a[i];
}
int res = 1<<29;
for (int bit = 0; bit < (1<<n); ++bit) {
int tmp = 0;
for (int j = 0; j < n; ++j) if (bit & (1<<j)) tmp += a[j];
chmin(res, abs(sum - tmp*2));
}
cout << res << endl;
}
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
Find the least common multiple (LCM) of given n integers.
Constraints
* 2 β€ n β€ 10
* 1 β€ ai β€ 1000
* Product of given integers ai(i = 1, 2, ... n) does not exceed 231-1
Input
n
a1 a2 ... an
n is given in the first line. Then, n integers are given in the second line.
Output
Print the least common multiple of the given integers in a line.
Examples
Input
3
3 4 6
Output
12
Input
4
1 2 3 5
Output
30
### Response
```cpp
#include <iostream>
using namespace std;
long long gcd(long long a, long long b){
int r = 0;
while(true){
/*a = abs(a);
b = abs(b);*/
r = a % b;
a = b;
b = r;
if(r == 0){break;}
}
return a;
}
long long lcm(long long a, long long b){
int L = 0;
int G = gcd(a,b);
L = a / G * b;
return L;
}
int main(){
long long N, Input;
long long anslcm = 1;
cin >> N;
for(int i = 0; i < N; i++){
cin >> Input;
anslcm = lcm(anslcm,Input);
}
cout << anslcm << endl;
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
This is an interactive problem. Refer to the Interaction section below for better understanding.
Ithea and Chtholly want to play a game in order to determine who can use the kitchen tonight.
<image>
Initially, Ithea puts n clear sheets of paper in a line. They are numbered from 1 to n from left to right.
This game will go on for m rounds. In each round, Ithea will give Chtholly an integer between 1 and c, and Chtholly needs to choose one of the sheets to write down this number (if there is already a number before, she will erase the original one and replace it with the new one).
Chtholly wins if, at any time, all the sheets are filled with a number and the n numbers are in non-decreasing order looking from left to right from sheet 1 to sheet n, and if after m rounds she still doesn't win, she loses the game.
Chtholly really wants to win the game as she wants to cook something for Willem. But she doesn't know how to win the game. So Chtholly finds you, and your task is to write a program to receive numbers that Ithea gives Chtholly and help her make the decision on which sheet of paper write this number.
Input
The first line contains 3 integers n, m and c (<image>, <image> means <image> rounded up) β the number of sheets, the number of rounds and the largest possible number Ithea can give to Chtholly respectively. The remaining parts of input are given throughout the interaction process.
Interaction
In each round, your program needs to read one line containing a single integer pi (1 β€ pi β€ c), indicating the number given to Chtholly.
Your program should then output a line containing an integer between 1 and n, indicating the number of sheet to write down this number in.
After outputting each line, don't forget to flush the output. For example:
* fflush(stdout) in C/C++;
* System.out.flush() in Java;
* sys.stdout.flush() in Python;
* flush(output) in Pascal;
* See the documentation for other languages.
If Chtholly wins at the end of a round, no more input will become available and your program should terminate normally. It can be shown that under the constraints, it's always possible for Chtholly to win the game.
Example
Input
2 4 4
2
1
3
Output
1
2
2
Note
In the example, Chtholly initially knew there were 2 sheets, 4 rounds and each number was between 1 and 4. She then received a 2 and decided to write it in the 1st sheet. Then she received a 1 and wrote it in the 2nd sheet. At last, she received a 3 and replaced 1 with 3 in the 2nd sheet. At this time all the sheets were filled with a number and they were non-decreasing, so she won the game.
Note that it is required that your program terminate immediately after Chtholly wins and do not read numbers from the input for the remaining rounds. If not, undefined behaviour may arise and it won't be sure whether your program will be accepted or rejected. Also because of this, please be careful when hacking others' codes. In the sample, Chtholly won the game after the 3rd round, so it is required that your program doesn't read the number of the remaining 4th round.
The input format for hacking:
* The first line contains 3 integers n, m and c;
* The following m lines each contains an integer between 1 and c, indicating the number given to Chtholly in each round.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, c;
cin >> n >> m >> c;
int low = 0;
int up = 0;
int arr[n + 1];
while ((low + up) != n) {
int p;
cin >> p;
if (p > c / 2) {
int t = n;
while (n - t < up) {
if (p > arr[t]) {
cout << t << endl;
arr[t] = p;
break;
}
t--;
}
if (n - t == up) {
cout << t << endl;
arr[t] = p;
up++;
}
} else {
int t = 1;
while (t < (low + 1)) {
if (p < arr[t]) {
cout << t << endl;
arr[t] = p;
break;
}
t++;
}
if (t == (low + 1)) {
cout << t << endl;
arr[t] = p;
low++;
}
}
}
return 0;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
Suppose you are given a string s of length n consisting of lowercase English letters. You need to compress it using the smallest possible number of coins.
To compress the string, you have to represent s as a concatenation of several non-empty strings: s = t_{1} t_{2} β¦ t_{k}. The i-th of these strings should be encoded with one of the two ways:
* if |t_{i}| = 1, meaning that the current string consists of a single character, you can encode it paying a coins;
* if t_{i} is a substring of t_{1} t_{2} β¦ t_{i - 1}, then you can encode it paying b coins.
A string x is a substring of a string y if x can be obtained from y by deletion of several (possibly, zero or all) characters from the beginning and several (possibly, zero or all) characters from the end.
So your task is to calculate the minimum possible number of coins you need to spend in order to compress the given string s.
Input
The first line contains three positive integers, separated by spaces: n, a and b (1 β€ n, a, b β€ 5000) β the length of the string, the cost to compress a one-character string and the cost to compress a string that appeared before.
The second line contains a single string s, consisting of n lowercase English letters.
Output
Output a single integer β the smallest possible number of coins you need to spend to compress s.
Examples
Input
3 3 1
aba
Output
7
Input
4 1 1
abcd
Output
4
Input
4 10 1
aaaa
Output
12
Note
In the first sample case, you can set t_{1} = 'a', t_{2} = 'b', t_{3} = 'a' and pay 3 + 3 + 1 = 7 coins, since t_{3} is a substring of t_{1}t_{2}.
In the second sample, you just need to compress every character by itself.
In the third sample, you set t_{1} = t_{2} = 'a', t_{3} = 'aa' and pay 10 + 1 + 1 = 12 coins, since t_{2} is a substring of t_{1} and t_{3} is a substring of t_{1} t_{2}.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MN = 5005, LOG = 15, inf = 1000000005, mod = 1000000007;
const long long INF = 1000000000000000005LL;
int dp[MN];
bitset<MN> fajny[MN];
pair<short int, short int> pie[MN][MN];
int kmr[LOG][2 * MN];
char S[MN];
int n;
void licz(int poz) {
vector<pair<short int, short int> > P;
for (int i = 1; i <= n; ++i)
P.push_back({kmr[poz - 1][i], kmr[poz - 1][i + (1 << (poz - 1))]});
sort((P).begin(), (P).end());
for (int i = 1; i <= n; ++i) {
pair<short int, short int> cur = {kmr[poz - 1][i],
kmr[poz - 1][i + (1 << (poz - 1))]};
kmr[poz][i] = (int)(lower_bound((P).begin(), (P).end(), cur) - P.begin());
}
}
pair<short int, short int> hasz(int i, int j) {
int len = j - i + 1;
int wyk = 31 - __builtin_clz(len);
int pot = (1 << wyk);
return {kmr[wyk][i], kmr[wyk][j - pot + 1]};
}
int main() {
int a, b;
scanf("%d%d%d", &n, &a, &b);
scanf("%s", S);
for (int i = 1; i <= n; ++i) kmr[0][i] = S[i - 1] - 'a';
for (int i = 1; i < LOG; ++i) licz(i);
for (int l = 1; l <= n; ++l)
for (int i = 1; i + l - 1 <= n; ++i) {
pair<short int, short int> h = hasz(i, i + l - 1);
if (pie[h.first][h.second].first == l) {
if (pie[h.first][h.second].second + l - 1 < i) fajny[i][i + l - 1] = 1;
} else {
pie[h.first][h.second] = {l, i};
}
}
for (int i = 1; i <= n; ++i) {
dp[i] = dp[i - 1] + a;
for (int j = i; j > 0; --j)
if (fajny[j][i]) dp[i] = min(dp[i], dp[j - 1] + b);
}
printf("%d", dp[n]);
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
You are given a convex polygon. Count, please, the number of triangles that contain a given point in the plane and their vertices are the vertices of the polygon. It is guaranteed, that the point doesn't lie on the sides and the diagonals of the polygon.
Input
The first line contains integer n β the number of vertices of the polygon (3 β€ n β€ 100000). The polygon description is following: n lines containing coordinates of the vertices in clockwise order (integer x and y not greater than 109 by absolute value). It is guaranteed that the given polygon is nondegenerate and convex (no three points lie on the same line).
The next line contains integer t (1 β€ t β€ 20) β the number of points which you should count the answer for. It is followed by t lines with coordinates of the points (integer x and y not greater than 109 by absolute value).
Output
The output should contain t integer numbers, each on a separate line, where i-th number is the answer for the i-th point.
Please, do not use %lld specificator to read or write 64-bit integers in C++. It is preffered to use cin (also you may use %I64d).
Examples
Input
4
5 0
0 0
0 5
5 5
1
1 3
Output
2
Input
3
0 0
0 5
5 0
2
1 1
10 10
Output
1
0
Input
5
7 6
6 3
4 1
1 2
2 4
4
3 3
2 3
5 5
4 2
Output
5
3
3
4
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long cross(pair<int, int> a, pair<int, int> b) {
return 1LL * a.first * b.second - 1LL * a.second * b.first;
}
long long ccw(pair<int, int> a, pair<int, int> b, pair<int, int> c) {
pair<int, int> p = pair<int, int>(b.first - a.first, b.second - a.second);
pair<int, int> q = pair<int, int>(c.first - a.first, c.second - a.second);
return cross(p, q);
}
int N, Q;
pair<int, int> P[100010];
int main() {
scanf("%d", &N);
for (int i = 0; i < N; i++) {
scanf("%d %d", &P[i].first, &P[i].second);
}
scanf("%d", &Q);
for (int q = 0; q < Q; q++) {
int x, y;
scanf("%d %d", &x, &y);
bool out = false;
for (int i = 0; i < N; i++) {
int j = (i + 1) % N;
if (ccw(pair<int, int>(x, y), P[i], P[j]) >= 0) {
out = true;
break;
}
}
if (out) {
printf("0\n");
continue;
}
long long ans = 1LL * N * (N - 1) * (N - 2) / 6;
int pos = 0;
for (int i = 0; i < N; i++) {
while (ccw(P[i], P[pos], pair<int, int>(x, y)) <= 0) pos = (pos + 1) % N;
int n = (pos - i + N) % N - 1;
ans -= 1LL * n * (n - 1) / 2;
}
printf("%lld\n", ans);
}
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
There are N towns in Takahashi Kingdom. They are conveniently numbered 1 through N.
Takahashi the king is planning to go on a tour of inspection for M days. He will determine a sequence of towns c, and visit town c_i on the i-th day. That is, on the i-th day, he will travel from his current location to town c_i. If he is already at town c_i, he will stay at that town. His location just before the beginning of the tour is town 1, the capital. The tour ends at town c_M, without getting back to the capital.
The problem is that there is no paved road in this kingdom. He decided to resolve this issue by paving the road himself while traveling. When he travels from town a to town b, there will be a newly paved one-way road from town a to town b.
Since he cares for his people, he wants the following condition to be satisfied after his tour is over: "it is possible to travel from any town to any other town by traversing roads paved by him". How many sequences of towns c satisfy this condition?
Constraints
* 2β¦Nβ¦300
* 1β¦Mβ¦300
Input
The input is given from Standard Input in the following format:
N M
Output
Print the number of sequences of towns satisfying the condition, modulo 1000000007 (=10^9+7).
Examples
Input
3 3
Output
2
Input
150 300
Output
734286322
Input
300 150
Output
0
### Response
```cpp
#include <bits/stdc++.h>
#define int long long
#define r(i,n) for(int i=0;i<n;i++)
using namespace std;
int dp[2][333][333],ans,n,m;
int mod=1000000007;
signed main(){
cin>>n>>m;
dp[0][1][1]=1;
for(int i=0;i<m;i++){
for(int j=0;j<=n;j++){
for(int k=0;k<=n;k++){
dp[(i+1)%2][j+1][k]+=dp[i%2][j][k]*(n-j);
dp[(i+1)%2][j][j]+=dp[i%2][j][k]*k;
dp[(i+1)%2][j][k]+=dp[i%2][j][k]*(j-k);
dp[(i+1)%2][j+1][k]%=mod;
dp[(i+1)%2][j][j]%=mod;
dp[(i+1)%2][j][k]%=mod;
}
}
r(k,333)r(j,333)dp[i%2][k][j]=0;
}
cout<<dp[m%2][n][n]<<endl;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
You are given a rectangle grid. That grid's size is n Γ m. Let's denote the coordinate system on the grid. So, each point on the grid will have coordinates β a pair of integers (x, y) (0 β€ x β€ n, 0 β€ y β€ m).
Your task is to find a maximum sub-rectangle on the grid (x1, y1, x2, y2) so that it contains the given point (x, y), and its length-width ratio is exactly (a, b). In other words the following conditions must hold: 0 β€ x1 β€ x β€ x2 β€ n, 0 β€ y1 β€ y β€ y2 β€ m, <image>.
The sides of this sub-rectangle should be parallel to the axes. And values x1, y1, x2, y2 should be integers.
<image>
If there are multiple solutions, find the rectangle which is closest to (x, y). Here "closest" means the Euclid distance between (x, y) and the center of the rectangle is as small as possible. If there are still multiple solutions, find the lexicographically minimum one. Here "lexicographically minimum" means that we should consider the sub-rectangle as sequence of integers (x1, y1, x2, y2), so we can choose the lexicographically minimum one.
Input
The first line contains six integers n, m, x, y, a, b (1 β€ n, m β€ 109, 0 β€ x β€ n, 0 β€ y β€ m, 1 β€ a β€ n, 1 β€ b β€ m).
Output
Print four integers x1, y1, x2, y2, which represent the founded sub-rectangle whose left-bottom point is (x1, y1) and right-up point is (x2, y2).
Examples
Input
9 9 5 5 2 1
Output
1 3 9 7
Input
100 100 52 50 46 56
Output
17 8 86 92
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m, x, y, a, b, k;
pair<int, int> ll, ur, o;
int gcd(int a, int b) {
while (b != 0) {
int tmp = b;
b = a % b;
a = tmp;
}
return a;
}
int main() {
cin >> n >> m >> x >> y >> a >> b;
int g = gcd(a, b);
a /= g;
b /= g;
k = min(n / a, m / b);
ll.first = ll.second = 0;
ur.first = a * k;
ur.second = b * k;
o.first = (ur.first + 1) / 2;
o.second = (ur.second + 1) / 2;
if (x >= o.first) {
if (n - a * k + o.first < x) {
ll.first = n - a * k;
ur.first = n;
} else {
ll.first += x - o.first;
ur.first += x - o.first;
}
}
if (y >= o.second) {
if (m - b * k + o.second < y) {
ll.second = m - b * k;
ur.second = m;
} else {
ll.second += y - o.second;
ur.second += y - o.second;
}
}
printf("%d %d %d %d\n", ll.first, ll.second, ur.first, ur.second);
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
You are given two positive integers a and b.
In one move, you can change a in the following way:
* Choose any positive odd integer x (x > 0) and replace a with a+x;
* choose any positive even integer y (y > 0) and replace a with a-y.
You can perform as many such operations as you want. You can choose the same numbers x and y in different moves.
Your task is to find the minimum number of moves required to obtain b from a. It is guaranteed that you can always obtain b from a.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 10^4) β the number of test cases.
Then t test cases follow. Each test case is given as two space-separated integers a and b (1 β€ a, b β€ 10^9).
Output
For each test case, print the answer β the minimum number of moves required to obtain b from a if you can perform any number of moves described in the problem statement. It is guaranteed that you can always obtain b from a.
Example
Input
5
2 3
10 10
2 4
7 4
9 3
Output
1
0
2
2
1
Note
In the first test case, you can just add 1.
In the second test case, you don't need to do anything.
In the third test case, you can add 1 two times.
In the fourth test case, you can subtract 4 and add 1.
In the fifth test case, you can just subtract 6.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
scanf("%d", &t);
while (t--) {
int a, b;
scanf("%d %d", &a, &b);
if (a == b)
printf("0\n");
else if (a > b) {
int cur = a - b;
if (cur % 2 == 0) {
printf("1\n");
} else
printf("2\n");
} else {
int cur = b - a;
if (cur % 2 == 1) {
printf("1\n");
} else
printf("2\n");
}
}
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
You are given a 4x4 grid. You play a game β there is a sequence of tiles, each of them is either 2x1 or 1x2. Your task is to consequently place all tiles from the given sequence in the grid. When tile is placed, each cell which is located in fully occupied row or column is deleted (cells are deleted at the same time independently). You can place tile in the grid at any position, the only condition is that tiles (and tile parts) should not overlap. Your goal is to proceed all given figures and avoid crossing at any time.
Input
The only line contains a string s consisting of zeroes and ones (1 β€ |s| β€ 1000). Zero describes vertical tile, one describes horizontal tile.
Output
Output |s| lines β for each tile you should output two positive integers r,c, not exceeding 4, representing numbers of smallest row and column intersecting with it.
If there exist multiple solutions, print any of them.
Example
Input
010
Output
1 1
1 2
1 4
Note
Following image illustrates the example after placing all three tiles:
<image> Then the first row is deleted: <image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int v = 0, h = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '0') {
v++;
if (v == 1)
cout << "1 1\n";
else
cout << "3 1\n", v = 0;
} else {
h++;
cout << h << " 2\n";
if (h == 4) h = 0;
}
}
return 0;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
Hacker Zhorik wants to decipher two secret messages he intercepted yesterday. Yeah message is a sequence of encrypted blocks, each of them consists of several bytes of information.
Zhorik knows that each of the messages is an archive containing one or more files. Zhorik knows how each of these archives was transferred through the network: if an archive consists of k files of sizes l1, l2, ..., lk bytes, then the i-th file is split to one or more blocks bi, 1, bi, 2, ..., bi, mi (here the total length of the blocks bi, 1 + bi, 2 + ... + bi, mi is equal to the length of the file li), and after that all blocks are transferred through the network, maintaining the order of files in the archive.
Zhorik thinks that the two messages contain the same archive, because their total lengths are equal. However, each file can be split in blocks in different ways in the two messages.
You are given the lengths of blocks in each of the two messages. Help Zhorik to determine what is the maximum number of files could be in the archive, if the Zhorik's assumption is correct.
Input
The first line contains two integers n, m (1 β€ n, m β€ 105) β the number of blocks in the first and in the second messages.
The second line contains n integers x1, x2, ..., xn (1 β€ xi β€ 106) β the length of the blocks that form the first message.
The third line contains m integers y1, y2, ..., ym (1 β€ yi β€ 106) β the length of the blocks that form the second message.
It is guaranteed that x1 + ... + xn = y1 + ... + ym. Also, it is guaranteed that x1 + ... + xn β€ 106.
Output
Print the maximum number of files the intercepted array could consist of.
Examples
Input
7 6
2 5 3 1 11 4 4
7 8 2 4 1 8
Output
3
Input
3 3
1 10 100
1 100 10
Output
2
Input
1 4
4
1 1 1 1
Output
1
Note
In the first example the maximum number of files in the archive is 3. For example, it is possible that in the archive are three files of sizes 2 + 5 = 7, 15 = 3 + 1 + 11 = 8 + 2 + 4 + 1 and 4 + 4 = 8.
In the second example it is possible that the archive contains two files of sizes 1 and 110 = 10 + 100 = 100 + 10. Note that the order of files is kept while transferring archives through the network, so we can't say that there are three files of sizes 1, 10 and 100.
In the third example the only possibility is that the archive contains a single file of size 4.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int ar[1000000], br[100000];
int main() {
int cnt = 0, m, n, sum = 0, sum1 = 0;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> ar[i];
for (int i = 0; i < m; i++) cin >> br[i];
int i = 0, j = 0;
while (i < n && j < m) {
if (sum == sum1) {
cnt++;
sum = ar[i++];
sum1 = br[j++];
} else if (sum > sum1) {
sum1 += br[j++];
} else
sum += ar[i++];
}
cout << cnt << endl;
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
In the city of Saint Petersburg, a day lasts for 2^{100} minutes. From the main station of Saint Petersburg, a train departs after 1 minute, 4 minutes, 16 minutes, and so on; in other words, the train departs at time 4^k for each integer k β₯ 0. Team BowWow has arrived at the station at the time s and it is trying to count how many trains have they missed; in other words, the number of trains that have departed strictly before time s. For example if s = 20, then they missed trains which have departed at 1, 4 and 16. As you are the only one who knows the time, help them!
Note that the number s will be given you in a [binary representation](https://en.wikipedia.org/wiki/Binary_number#Representation) without leading zeroes.
Input
The first line contains a single binary number s (0 β€ s < 2^{100}) without leading zeroes.
Output
Output a single number β the number of trains which have departed strictly before the time s.
Examples
Input
100000000
Output
4
Input
101
Output
2
Input
10100
Output
3
Note
In the first example 100000000_2 = 256_{10}, missed trains have departed at 1, 4, 16 and 64.
In the second example 101_2 = 5_{10}, trains have departed at 1 and 4.
The third example is explained in the statements.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
const int M = 1e9 + 7;
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
string s;
cin >> s;
int o = 0;
if (s == "0") return cout << 0, 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '1') o++;
}
int k = int(s.size()) - 1;
int ans = k / 2;
if (o != 1 || k & 1) ans++;
cout << ans;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
You are given an array a of n integers, where n is odd. You can make the following operation with it:
* Choose one of the elements of the array (for example a_i) and increase it by 1 (that is, replace it with a_i + 1).
You want to make the median of the array the largest possible using at most k operations.
The median of the odd-sized array is the middle element after the array is sorted in non-decreasing order. For example, the median of the array [1, 5, 2, 3, 5] is 3.
Input
The first line contains two integers n and k (1 β€ n β€ 2 β
10^5, n is odd, 1 β€ k β€ 10^9) β the number of elements in the array and the largest number of operations you can make.
The second line contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9).
Output
Print a single integer β the maximum possible median after the operations.
Examples
Input
3 2
1 3 5
Output
5
Input
5 5
1 2 1 1 1
Output
3
Input
7 7
4 1 2 4 3 4 4
Output
5
Note
In the first example, you can increase the second element twice. Than array will be [1, 5, 5] and it's median is 5.
In the second example, it is optimal to increase the second number and than increase third and fifth. This way the answer is 3.
In the third example, you can make four operations: increase first, fourth, sixth, seventh element. This way the array will be [5, 1, 2, 5, 3, 5, 5] and the median will be 5.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200003;
const long long INF = 1000000000000ll;
int n;
long long k, a[maxn];
int main() {
scanf("%d%lld", &n, &k);
for (int i = 1; i <= n; i++) scanf("%lld", a + i);
sort(a + 1, a + n + 1);
a[n + 1] = INF;
int i = n / 2 + 1, j = i;
long long cnt = 0, ans = a[i];
while (1) {
for (; j <= n && a[i] == a[j]; j++)
;
if (cnt + (j - n / 2 - 1) * (a[j] - a[i]) > k) break;
cnt += (j - n / 2 - 1) * (a[j] - a[i]);
ans = a[j];
i = j;
}
ans += (k - cnt) / (j - n / 2 - 1);
printf("%lld\n", ans);
return 0;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
Professor GukiZ makes a new robot. The robot are in the point with coordinates (x1, y1) and should go to the point (x2, y2). In a single step the robot can change any of its coordinates (maybe both of them) by one (decrease or increase). So the robot can move in one of the 8 directions. Find the minimal number of steps the robot should make to get the finish position.
Input
The first line contains two integers x1, y1 ( - 109 β€ x1, y1 β€ 109) β the start position of the robot.
The second line contains two integers x2, y2 ( - 109 β€ x2, y2 β€ 109) β the finish position of the robot.
Output
Print the only integer d β the minimal number of steps to get the finish position.
Examples
Input
0 0
4 5
Output
5
Input
3 4
6 1
Output
3
Note
In the first example robot should increase both of its coordinates by one four times, so it will be in position (4, 4). After that robot should simply increase its y coordinate and get the finish position.
In the second example robot should simultaneously increase x coordinate and decrease y coordinate by one three times.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int x1, y1, x2, y2, ans;
cin >> x1 >> y1 >> x2 >> y2;
long long int minm = min(abs(x2 - x1), abs(y2 - y1));
if (minm == abs(x2 - x1))
ans = max(y1, y2) - min(y1, y2);
else
ans = max(x1, x2) - min(x1, x2);
cout << ans;
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
Arseniy is already grown-up and independent. His mother decided to leave him alone for m days and left on a vacation. She have prepared a lot of food, left some money and washed all Arseniy's clothes.
Ten minutes before her leave she realized that it would be also useful to prepare instruction of which particular clothes to wear on each of the days she will be absent. Arseniy's family is a bit weird so all the clothes is enumerated. For example, each of Arseniy's n socks is assigned a unique integer from 1 to n. Thus, the only thing his mother had to do was to write down two integers li and ri for each of the days β the indices of socks to wear on the day i (obviously, li stands for the left foot and ri for the right). Each sock is painted in one of k colors.
When mother already left Arseniy noticed that according to instruction he would wear the socks of different colors on some days. Of course, that is a terrible mistake cause by a rush. Arseniy is a smart boy, and, by some magical coincidence, he posses k jars with the paint β one for each of k colors.
Arseniy wants to repaint some of the socks in such a way, that for each of m days he can follow the mother's instructions and wear the socks of the same color. As he is going to be very busy these days he will have no time to change the colors of any socks so he has to finalize the colors now.
The new computer game Bota-3 was just realised and Arseniy can't wait to play it. What is the minimum number of socks that need their color to be changed in order to make it possible to follow mother's instructions and wear the socks of the same color during each of m days.
Input
The first line of input contains three integers n, m and k (2 β€ n β€ 200 000, 0 β€ m β€ 200 000, 1 β€ k β€ 200 000) β the number of socks, the number of days and the number of available colors respectively.
The second line contain n integers c1, c2, ..., cn (1 β€ ci β€ k) β current colors of Arseniy's socks.
Each of the following m lines contains two integers li and ri (1 β€ li, ri β€ n, li β ri) β indices of socks which Arseniy should wear during the i-th day.
Output
Print one integer β the minimum number of socks that should have their colors changed in order to be able to obey the instructions and not make people laugh from watching the socks of different colors.
Examples
Input
3 2 3
1 2 3
1 2
2 3
Output
2
Input
3 2 2
1 1 2
1 2
2 1
Output
0
Note
In the first sample, Arseniy can repaint the first and the third socks to the second color.
In the second sample, there is no need to change any colors.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const string alf = "abcdefghijklmnopqrstuvwxyz";
const int hashP = 239017;
const int N = 1e5 + 10;
const int MOD = 1e9 + 7;
const int MOD2 = 998244353;
const int INF = 1e9;
const long long oo = 9e18;
template <typename T>
bool umn(T &a, T b) {
return (a > b ? (a = b, 1) : 0);
}
template <typename T>
bool umx(T &a, T b) {
return (a < b ? (a = b, 1) : 0);
}
long long p[2 * N], sz[2 * N];
vector<long long> g[2 * N];
long long find_set(long long v) {
if (p[v] == v)
return v;
else
return p[v] = find_set(p[v]);
}
void unite_sets(long long a, long long b) {
a = find_set(a);
b = find_set(b);
if (sz[a] < sz[b]) swap(a, b);
sz[a] += sz[b];
p[b] = a;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, m, k;
cin >> n >> m >> k;
for (int i = 0; i < 2 * N; i++) {
sz[i] = 1;
p[i] = i;
}
vector<long long> a(n);
for (auto &now : a) cin >> now;
for (int i = 0; i < m; i++) {
long long l, r;
cin >> l >> r;
unite_sets(l, r);
}
set<long long> s;
for (int i = 1; i <= n; i++) {
g[find_set(i)].push_back(i);
s.insert(find_set(i));
}
long long ans = 0;
for (auto now : s) {
map<long long, long long> mapa;
for (auto now2 : g[now]) {
mapa[a[now2 - 1]]++;
}
long long maxi = 0, sum = 0;
for (auto now : mapa) {
sum += now.second;
umx(maxi, now.second);
}
ans += sum - maxi;
}
cout << ans;
return 0;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
You're given the centers of three equal sides of a strictly convex tetragon. Your task is to restore the initial tetragon.
Input
The first input line contains one number T β amount of tests (1 β€ T β€ 5Β·104). Each of the following T lines contains numbers x1, y1, x2, y2, x3, y3 β coordinates of different points that are the centers of three equal sides (non-negative integer numbers, not exceeding 10).
Output
For each test output two lines. If the required tetragon exists, output in the first line YES, in the second line β four pairs of numbers β coordinates of the polygon's vertices in clockwise or counter-clockwise order. Don't forget, please, that the tetragon should be strictly convex, i.e. no 3 of its points lie on one line. Output numbers with 9 characters after a decimal point.
If the required tetragon doen't exist, output NO in the first line, and leave the second line empty.
Examples
Input
3
1 1 2 2 3 3
0 1 1 0 2 2
9 3 7 9 9 8
Output
NO
YES
3.5 1.5 0.5 2.5 -0.5 -0.5 2.5 0.5
NO
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int Get() {
char c;
while (c = getchar(), c < '0' || c > '9')
;
int X = c - 48;
while (c = getchar(), c >= '0' && c <= '9') X = X * 10 + c - 48;
return X;
}
double Cross(double Xa, double Ya, double Xb, double Yb, double Xc, double Yc) {
return (Xa * Yb + Xb * Yc + Xc * Ya) - (Xb * Ya + Xc * Yb + Xa * Yc);
}
bool Check(int Xa, int Ya, int Xb, int Yb, int Xc, int Yc) {
double A0 = 2 * (Xa - Xb), B0 = 2 * (Ya - Yb);
double C0 = Xb * Xb - Xa * Xa + Yb * Yb - Ya * Ya;
double A1 = 2 * (Xb - Xc), B1 = 2 * (Yb - Yc);
double C1 =
-3 * (Xb * Xb + Yb * Yb) - (Xc * Xc + Yc * Yc) + 4 * (Xb * Xc + Yb * Yc);
double Xp = (C1 * B0 - C0 * B1) / (A0 * B1 - A1 * B0);
double Yp = (A1 * C0 - A0 * C1) / (A0 * B1 - A1 * B0);
double Xq = 2 * Xb - Xp, Yq = 2 * Yb - Yp;
double _Xp = 2 * Xa - Xp, _Yp = 2 * Ya - Yp;
double _Xq = 2 * Xc - Xq, _Yq = 2 * Yc - Yq;
double a = Cross(_Xp, _Yp, Xp, Yp, Xq, Yq);
double b = Cross(Xp, Yp, Xq, Yq, _Xq, _Yq);
double c = Cross(Xq, Yq, _Xq, _Yq, _Xp, _Yp);
double d = Cross(_Xq, _Yq, _Xp, _Yp, Xp, Yp);
if ((a < 0 && b < 0 && c < 0 && d < 0) ||
(a > 0 && b > 0 && c > 0 && d > 0)) {
printf("YES\n");
printf("%0.10lf %0.10lf ", Xp, Yp);
printf("%0.10lf %0.10lf ", Xq, Yq);
printf("%0.10lf %0.10lf ", _Xq, _Yq);
printf("%0.10lf %0.10lf\n", _Xp, _Yp);
return true;
}
return false;
}
void Work(int Xa, int Ya, int Xb, int Yb, int Xc, int Yc) {
if (Cross(Xa, Ya, Xb, Yb, Xc, Yc)) {
if (Check(Xa, Ya, Xb, Yb, Xc, Yc)) return;
if (Check(Xb, Yb, Xc, Yc, Xa, Ya)) return;
if (Check(Xc, Yc, Xa, Ya, Xb, Yb)) return;
}
printf("NO\n\n");
}
int main() {
int Test = Get();
while (Test--) {
int Xa = Get(), Ya = Get();
int Xb = Get(), Yb = Get();
int Xc = Get(), Yc = Get();
Work(Xa, Ya, Xb, Yb, Xc, Yc);
}
return 0;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
Peterson loves to learn new languages, but his favorite hobby is making new ones. Language is a set of words, and word is a sequence of lowercase Latin letters.
Peterson makes new language every morning. It is difficult task to store the whole language, so Peterson have invented new data structure for storing his languages which is called broom. Broom is rooted tree with edges marked with letters. Initially broom is represented by the only vertex β the root of the broom. When Peterson wants to add new word to the language he stands at the root and processes the letters of new word one by one. Consider that Peterson stands at the vertex u. If there is an edge from u marked with current letter, Peterson goes through this edge. Otherwise Peterson adds new edge from u to the new vertex v, marks it with the current letter and goes through the new edge. Size of broom is the number of vertices in it.
In the evening after working day Peterson can't understand the language he made this morning. It is too difficult for bored Peterson and he tries to make it simpler. Simplification of the language is the process of erasing some letters from some words of this language. Formally, Peterson takes some positive integer p and erases p-th letter from all the words of this language having length at least p. Letters in words are indexed starting by 1. Peterson considers that simplification should change at least one word, i.e. there has to be at least one word of length at least p. Peterson tries to make his language as simple as possible, so he wants to choose p such that the size of the broom for his simplified language is as small as possible.
Peterson is pretty annoyed with this task so he asks you for help. Write a program to find the smallest possible size of the broom and integer p.
Input
The first line of input contains integer n (2 β€ n β€ 3Β·105) β the size of the broom.
Next n - 1 lines describe the broom: i-th of them contains integers ui, vi and letter xi β describing the edge from ui to vi marked with letter xi.
Vertices are numbered from 1 to n. All xi are lowercase latin letters. Vertex 1 is the root of the broom.
Edges describe correct broom which is made from Peterson's language.
Output
The first line of output should contain the minimum possible size of the broom after its simplification. The second line of output should contain integer p to choose. If there are several suitable p values, print the smallest one.
Examples
Input
5
1 2 c
2 3 a
3 4 t
2 5 t
Output
3
2
Input
16
1 2 o
2 3 f
1 4 p
4 5 i
5 6 e
6 7 c
7 8 e
4 9 r
9 10 e
10 11 t
11 12 t
12 13 y
10 14 f
14 15 i
15 16 x
Output
12
2
Note
<image>
Broom from the second sample test can be built using language "piece", "of", "pie", "pretty", "prefix". Its simplification with p = 2 obtains the language of words "pece", "o", "pe", "petty", "pefix". This language gives us the broom with minimum possible size.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10;
int md = 0;
int ans[maxn];
int g[maxn][26];
int merge(const vector<int>& a) {
int res = (int)(a).size() - 1;
vector<int> b;
for (int i = 0; i < 26; i++) {
b.clear();
for (auto u : a) {
if (g[u][i]) {
b.emplace_back(g[u][i]);
}
}
if ((int)(b).size() > 1) res += merge(b);
}
return res;
}
void dfs(int v, int d = 1) {
vector<int> tmp;
md = max(md, d);
for (int i = 0; i < 26; i++) {
if (g[v][i] == 0) continue;
tmp.emplace_back(g[v][i]);
}
int res = merge(tmp) + 1;
ans[d] += res;
for (int i = 0; i < 26; i++) {
if (g[v][i] == 0) continue;
dfs(g[v][i], d + 1);
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n - 1; ++i) {
int u, v;
char ch;
cin >> u >> v >> ch;
g[u][ch - 'a'] = v;
}
dfs(1);
int p = 1;
for (int i = 1; i <= md; ++i) {
if (ans[p] < ans[i]) {
p = i;
}
}
cout << n - ans[p] << "\n" << p << "\n";
return 0;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
You wrote down all integers from 0 to 10^n - 1, padding them with leading zeroes so their lengths are exactly n. For example, if n = 3 then you wrote out 000, 001, ..., 998, 999.
A block in an integer x is a consecutive segment of equal digits that cannot be extended to the left or to the right.
For example, in the integer 00027734000 there are three blocks of length 1, one block of length 2 and two blocks of length 3.
For all integers i from 1 to n count the number of blocks of length i among the written down integers.
Since these integers may be too large, print them modulo 998244353.
Input
The only line contains one integer n (1 β€ n β€ 2 β
10^5).
Output
In the only line print n integers. The i-th integer is equal to the number of blocks of length i.
Since these integers may be too large, print them modulo 998244353.
Examples
Input
1
Output
10
Input
2
Output
180 10
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long mod = 998244353;
long long binpow(long long a, long long n) {
long long res = 1;
while (n) {
if (n & 1) res = (res * a) % mod;
a = (a * a) % mod;
n >>= 1;
}
return res;
}
long long n;
vector<long long> ans;
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
ans.resize(n);
long long l = 0, cnt = 0;
long long a, b, c;
for (long long i = 0; i < n; i++) {
l = i + 1;
cnt = n - l + 1;
b = (10 * (9) * binpow(10, max((long long)0, n - l - 1))) % mod;
c = (10 * 9 * 9 * binpow(10, max((long long)0, n - l - 2))) % mod;
ans[i] = 0;
for (long long j = 0; j < 2; j++) {
if (cnt > 0) ans[i] = (ans[i] + b) % mod;
cnt--;
}
ans[i] = (ans[i] + max((long long)0, cnt) * c) % mod;
}
ans[n - 1] = 10;
for (auto e : ans) cout << e << " ";
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
Petya studies in a school and he adores Maths. His class has been studying arithmetic expressions. On the last class the teacher wrote three positive integers a, b, c on the blackboard. The task was to insert signs of operations '+' and '*', and probably brackets between the numbers so that the value of the resulting expression is as large as possible. Let's consider an example: assume that the teacher wrote numbers 1, 2 and 3 on the blackboard. Here are some ways of placing signs and brackets:
* 1+2*3=7
* 1*(2+3)=5
* 1*2*3=6
* (1+2)*3=9
Note that you can insert operation signs only between a and b, and between b and c, that is, you cannot swap integers. For instance, in the given sample you cannot get expression (1+3)*2.
It's easy to see that the maximum value that you can obtain is 9.
Your task is: given a, b and c print the maximum value that you can get.
Input
The input contains three integers a, b and c, each on a single line (1 β€ a, b, c β€ 10).
Output
Print the maximum value of the expression that you can obtain.
Examples
Input
1
2
3
Output
9
Input
2
10
3
Output
60
### Response
```cpp
#include <bits/stdc++.h>
int main() {
int a, b, c, r1, r2, r3, r4, r5, max, i;
scanf("%d%d%d", &a, &b, &c);
r1 = a + b * c;
r2 = a * (b + c);
r3 = a * b * c;
r4 = (a + b) * c;
r5 = a + b + c;
int s[] = {r1, r2, r3, r4, r5};
max = s[0];
for (i = 1; i < 5; i++) {
if (s[i] > max) {
max = s[i];
}
}
printf("%d\n", max);
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Little Artem is fond of dancing. Most of all dances Artem likes rueda β Cuban dance that is danced by pairs of boys and girls forming a circle and dancing together.
More detailed, there are n pairs of boys and girls standing in a circle. Initially, boy number 1 dances with a girl number 1, boy number 2 dances with a girl number 2 and so on. Girls are numbered in the clockwise order. During the dance different moves are announced and all pairs perform this moves. While performing moves boys move along the circle, while girls always stay at their initial position. For the purpose of this problem we consider two different types of moves:
1. Value x and some direction are announced, and all boys move x positions in the corresponding direction.
2. Boys dancing with even-indexed girls swap positions with boys who are dancing with odd-indexed girls. That is the one who was dancing with the girl 1 swaps with the one who was dancing with the girl number 2, while the one who was dancing with girl number 3 swaps with the one who was dancing with the girl number 4 and so one. It's guaranteed that n is even.
Your task is to determine the final position of each boy.
Input
The first line of the input contains two integers n and q (2 β€ n β€ 1 000 000, 1 β€ q β€ 2 000 000) β the number of couples in the rueda and the number of commands to perform, respectively. It's guaranteed that n is even.
Next q lines contain the descriptions of the commands. Each command has type as the integer 1 or 2 first. Command of the first type is given as x ( - n β€ x β€ n), where 0 β€ x β€ n means all boys moves x girls in clockwise direction, while - x means all boys move x positions in counter-clockwise direction. There is no other input for commands of the second type.
Output
Output n integers, the i-th of them should be equal to the index of boy the i-th girl is dancing with after performing all q moves.
Examples
Input
6 3
1 2
2
1 2
Output
4 3 6 5 2 1
Input
2 3
1 1
2
1 -2
Output
1 2
Input
4 2
2
1 3
Output
1 4 3 2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, q, c, x, z, a[2], b[2];
int main() {
a[0] = 0, a[1] = 1;
scanf("%d %d", &n, &q);
while (q--) {
scanf("%d", &c);
if (c == 1) {
scanf("%d", &x);
x %= n;
z = x < 0 ? -x : x;
b[0] = ((a[(z & 1)] - x - (z & 1)) % n + n) % n;
b[1] = ((a[!(z & 1)] - x + (z & 1)) % n + n) % n;
a[0] = b[0], a[1] = b[1];
} else
swap(a[0], a[1]);
}
for (int i = 0; i < n; ++i) printf("%d ", (a[i & 1] + i - (i & 1)) % n + 1);
}
``` |
### Prompt
Create a solution in CPP for the following problem:
Given an undirected tree, let the distance between vertices u and v be the number of edges on the simple path from u to v. The diameter of a tree is the maximum among the distances between any two vertices. We will call a tree good if and only if its diameter is at most K.
You are given an undirected tree with N vertices numbered 1 through N. For each i (1β¦iβ¦N-1), there is an edge connecting vertices A_i and B_i.
You want to remove zero or more vertices from the tree, so that the resulting tree is good. When a vertex is removed, all incident edges will also be removed. The resulting graph must be connected.
Find the minimum number of vertices that you need to remove in order to produce a good tree.
Constraints
* 2β¦Nβ¦2000
* 1β¦Kβ¦N-1
* 1β¦A_iβ¦N, 1β¦B_iβ¦N
* The graph defined by A_i and B_i is a tree.
Input
The input is given from Standard Input in the following format:
N K
A_1 B_1
A_2 B_2
:
A_{N-1} B_{N-1}
Output
Print the minimum number of vertices that you need to remove in order to produce a good tree.
Examples
Input
6 2
1 2
3 2
4 2
1 6
5 6
Output
2
Input
6 5
1 2
3 2
4 2
1 6
5 6
Output
0
### Response
```cpp
#include <cstdio>
#include <algorithm>
using namespace std;
const int N = 2010;
int n,head[N],to[N*2],nex[N*2],x,y,tot,k,ans;
void link(int x,int y)
{
nex[++tot]=head[x];
to[head[x]=tot]=y;
}
int dfs(int now, int lim, int f)
{
if(lim<0)
return 0;
int ans=1;
for(int i=head[now]; i; i=nex[i])
if(to[i]!=f)
ans+=dfs(to[i],lim-1,now);
return ans;
}
int main()
{
scanf("%d%d",&n,&k);
for(int i=1; i<n; i++)
{
scanf("%d%d",&x,&y);
link(x,y);
link(y,x);
}
for(int i=1; i<=n; i++)
{
if(k&1)
for(int j=head[i];j;j=nex[j])
ans=max(ans,dfs(i,k/2,to[j])+dfs(to[j],k/2,i));
else
ans=max(ans,dfs(i,k/2,0));
}
printf("%d",n - ans);
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
Takahashi is solving quizzes. He has easily solved all but the last one.
The last quiz has three choices: 1, 2, and 3.
With his supernatural power, Takahashi has found out that the choices A and B are both wrong.
Print the correct choice for this problem.
Constraints
* Each of the numbers A and B is 1, 2, or 3.
* A and B are different.
Input
Input is given from Standard Input in the following format:
A
B
Output
Print the correct choice.
Examples
Input
3
1
Output
2
Input
1
2
Output
3
### Response
```cpp
#include<iostream>
int a,b;int main(){std::cin>>a>>b,std::cout<<(a^b);}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
Arseniy is already grown-up and independent. His mother decided to leave him alone for m days and left on a vacation. She have prepared a lot of food, left some money and washed all Arseniy's clothes.
Ten minutes before her leave she realized that it would be also useful to prepare instruction of which particular clothes to wear on each of the days she will be absent. Arseniy's family is a bit weird so all the clothes is enumerated. For example, each of Arseniy's n socks is assigned a unique integer from 1 to n. Thus, the only thing his mother had to do was to write down two integers li and ri for each of the days β the indices of socks to wear on the day i (obviously, li stands for the left foot and ri for the right). Each sock is painted in one of k colors.
When mother already left Arseniy noticed that according to instruction he would wear the socks of different colors on some days. Of course, that is a terrible mistake cause by a rush. Arseniy is a smart boy, and, by some magical coincidence, he posses k jars with the paint β one for each of k colors.
Arseniy wants to repaint some of the socks in such a way, that for each of m days he can follow the mother's instructions and wear the socks of the same color. As he is going to be very busy these days he will have no time to change the colors of any socks so he has to finalize the colors now.
The new computer game Bota-3 was just realised and Arseniy can't wait to play it. What is the minimum number of socks that need their color to be changed in order to make it possible to follow mother's instructions and wear the socks of the same color during each of m days.
Input
The first line of input contains three integers n, m and k (2 β€ n β€ 200 000, 0 β€ m β€ 200 000, 1 β€ k β€ 200 000) β the number of socks, the number of days and the number of available colors respectively.
The second line contain n integers c1, c2, ..., cn (1 β€ ci β€ k) β current colors of Arseniy's socks.
Each of the following m lines contains two integers li and ri (1 β€ li, ri β€ n, li β ri) β indices of socks which Arseniy should wear during the i-th day.
Output
Print one integer β the minimum number of socks that should have their colors changed in order to be able to obey the instructions and not make people laugh from watching the socks of different colors.
Examples
Input
3 2 3
1 2 3
1 2
2 3
Output
2
Input
3 2 2
1 1 2
1 2
2 1
Output
0
Note
In the first sample, Arseniy can repaint the first and the third socks to the second color.
In the second sample, there is no need to change any colors.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int* sock;
int** ins;
const int N = 200010;
class DisjointSet {
public:
int p[N];
void Init(int n) {
for (int i = 1; i <= n; ++i) p[i] = i;
}
int Find(int x) { return x == p[x] ? x : p[x] = Find(p[x]); }
void Union(int x, int y) { p[Find(x)] = Find(y); }
};
DisjointSet d;
int main() {
int cnt = 0;
cin >> n >> m >> k;
sock = new int[n + 1];
ins = new int*[m];
sock[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> sock[i];
}
for (int i = 0; i < m; i++) {
ins[i] = new int[2];
}
d.Init(n);
for (int i = 0; i < m; i++) {
cin >> ins[i][0];
cin >> ins[i][1];
if (d.Find(ins[i][0] != d.Find(ins[i][1]))) {
d.Union(ins[i][0], ins[i][1]);
}
}
map<int, vector<int> > count;
map<int, vector<int> >::iterator it;
for (int i = 1; i <= n; i++) {
count[d.Find(i)].push_back(i);
}
for (it = count.begin(); it != count.end(); it++) {
map<int, int> tmp;
map<int, int>::iterator it2;
int maxNum = -1;
for (int i = 0; i < it->second.size(); i++) {
tmp[sock[it->second[i]]]++;
}
for (it2 = tmp.begin(); it2 != tmp.end(); it2++) {
if (it2->second > maxNum) {
maxNum = it2->second;
}
}
cnt += (it->second.size() - maxNum);
}
cout << cnt;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
A robot is put at the origin in a two-dimensional plane. Initially, the robot is facing in the positive x-axis direction.
This robot will be given an instruction sequence s. s consists of the following two kinds of letters, and will be executed in order from front to back.
* `F` : Move in the current direction by distance 1.
* `T` : Turn 90 degrees, either clockwise or counterclockwise.
The objective of the robot is to be at coordinates (x, y) after all the instructions are executed. Determine whether this objective is achievable.
Constraints
* s consists of `F` and `T`.
* 1 \leq |s| \leq 8 000
* x and y are integers.
* |x|, |y| \leq |s|
Input
Input is given from Standard Input in the following format:
s
x y
Output
If the objective is achievable, print `Yes`; if it is not, print `No`.
Examples
Input
FTFFTFFF
4 2
Output
Yes
Input
FTFFTFFF
-2 -2
Output
Yes
Input
FF
1 0
Output
No
Input
TF
1 0
Output
No
Input
FFTTFF
0 0
Output
Yes
Input
TTTT
1 0
Output
No
### Response
```cpp
#include <bits/stdc++.h>
#define mod 1000000007
#define pb push_back
#define ll long long
#define mp make_pair
using namespace std;
bitset<35000> x,y;
int main(){
ll xx,yy;
string s;
cin>>s>>xx>>yy;
ll n=s.size();
ll spos = 0;
while(spos<n && s[spos] == 'F'){
xx--;
spos++;
}
vector<ll> xmv,ymv;
ll mde = 0,cnt = 0;
for(int i=spos;i<n;i++){
if(s[i]=='T'){
if(mde == 0){
xmv.pb(cnt);
}
else{
ymv.pb(cnt);
}
cnt = 0;
mde=1-mde;
}
else{
cnt++;
}
}
if(mde == 0){
xmv.pb(cnt);
}
else{
ymv.pb(cnt);
}
/*for(int i=0;i<xmv.size();i++){
cout<<xmv[i]<<endl;
}
for(int i=0;i<ymv.size();i++){
cout<<ymv[i]<<endl;
}*/
ll ze = 17000;
x.set(ze);
for(int i=0;i<xmv.size();i++){
x = (x<<xmv[i])|(x>>xmv[i]);
}
y.set(ze);
for(int i=0;i<ymv.size();i++){
y = (y<<ymv[i])|(y>>ymv[i]);
}
if( x[xx+ze] & y[yy+ze] ){
cout<<"Yes"<<endl;
}
else{
cout<<"No"<<endl;
}
return 0;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
X and A are integers between 0 and 9 (inclusive).
If X is less than A, print 0; if X is not less than A, print 10.
Constraints
* 0 \leq X, A \leq 9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
X A
Output
If X is less than A, print 0; if X is not less than A, print 10.
Examples
Input
3 5
Output
0
Input
7 5
Output
10
Input
6 6
Output
10
### Response
```cpp
#include<iostream>
using namespace std;
int x,a;
int main(){
cin>>x>>a;
cout<<(x<a?0:10)<<endl;
return 0;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
Kevin and Nicky Sun have invented a new game called Lieges of Legendre. In this game, two players take turns modifying the game state with Kevin moving first. Initially, the game is set up so that there are n piles of cows, with the i-th pile containing ai cows. During each player's turn, that player calls upon the power of Sunlight, and uses it to either:
1. Remove a single cow from a chosen non-empty pile.
2. Choose a pile of cows with even size 2Β·x (x > 0), and replace it with k piles of x cows each.
The player who removes the last cow wins. Given n, k, and a sequence a1, a2, ..., an, help Kevin and Nicky find the winner, given that both sides play in optimal way.
Input
The first line of the input contains two space-separated integers n and k (1 β€ n β€ 100 000, 1 β€ k β€ 109).
The second line contains n integers, a1, a2, ... an (1 β€ ai β€ 109) describing the initial state of the game.
Output
Output the name of the winning player, either "Kevin" or "Nicky" (without quotes).
Examples
Input
2 1
3 4
Output
Kevin
Input
1 2
3
Output
Nicky
Note
In the second sample, Nicky can win in the following way: Kevin moves first and is forced to remove a cow, so the pile contains two cows after his move. Next, Nicky replaces this pile of size 2 with two piles of size 1. So the game state is now two piles of size 1. Kevin then removes one of the remaining cows and Nicky wins by removing the other.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int N, K;
int calc(int x) {
if (K == 0) {
if (x <= 2) return x;
return (x + 1) % 2;
} else {
if (x == 0) return 0;
if (x == 1) return 1;
if (x == 2) return 0;
if (x == 3) return 1;
if (x == 4) return 2;
if (x % 2) return 0;
int y = calc(x / 2);
if (y == 0) return 1;
if (y == 1) return 2;
if (y == 2) return 1;
}
}
int main() {
cin >> N >> K;
K %= 2;
int x = 0;
for (int i = 0; i < (int)(N); i++) {
int a;
cin >> a;
x ^= calc(a);
}
cout << (x > 0 ? "Kevin" : "Nicky") << endl;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
Alice has a birthday today, so she invited home her best friend Bob. Now Bob needs to find a way to commute to the Alice's home.
In the city in which Alice and Bob live, the first metro line is being built. This metro line contains n stations numbered from 1 to n. Bob lives near the station with number 1, while Alice lives near the station with number s. The metro line has two tracks. Trains on the first track go from the station 1 to the station n and trains on the second track go in reverse direction. Just after the train arrives to the end of its track, it goes to the depot immediately, so it is impossible to travel on it after that.
Some stations are not yet open at all and some are only partially open β for each station and for each track it is known whether the station is closed for that track or not. If a station is closed for some track, all trains going in this track's direction pass the station without stopping on it.
When the Bob got the information on opened and closed stations, he found that traveling by metro may be unexpectedly complicated. Help Bob determine whether he can travel to the Alice's home by metro or he should search for some other transport.
Input
The first line contains two integers n and s (2 β€ s β€ n β€ 1000) β the number of stations in the metro and the number of the station where Alice's home is located. Bob lives at station 1.
Next lines describe information about closed and open stations.
The second line contains n integers a_1, a_2, β¦, a_n (a_i = 0 or a_i = 1). If a_i = 1, then the i-th station is open on the first track (that is, in the direction of increasing station numbers). Otherwise the station is closed on the first track.
The third line contains n integers b_1, b_2, β¦, b_n (b_i = 0 or b_i = 1). If b_i = 1, then the i-th station is open on the second track (that is, in the direction of decreasing station numbers). Otherwise the station is closed on the second track.
Output
Print "YES" (quotes for clarity) if Bob will be able to commute to the Alice's home by metro and "NO" (quotes for clarity) otherwise.
You can print each letter in any case (upper or lower).
Examples
Input
5 3
1 1 1 1 1
1 1 1 1 1
Output
YES
Input
5 4
1 0 0 0 1
0 1 1 1 1
Output
YES
Input
5 2
0 1 1 1 1
1 1 1 1 1
Output
NO
Note
In the first example, all stations are opened, so Bob can simply travel to the station with number 3.
In the second example, Bob should travel to the station 5 first, switch to the second track and travel to the station 4 then.
In the third example, Bob simply can't enter the train going in the direction of Alice's home.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1010;
bool first[maxn];
bool second[maxn];
int main() {
ios::sync_with_stdio(false);
int n, s;
cin >> n >> s;
for (int i = 0; i < n; i++) {
cin >> first[i];
}
for (int i = 0; i < n; i++) {
cin >> second[i];
}
if (s == 1) {
cout << "YES";
return 0;
}
if (!first[0]) {
cout << "NO";
return 0;
}
if (first[s - 1]) {
cout << "YES";
return 0;
}
if (!second[s - 1]) {
cout << "NO";
return 0;
}
int i = s - 1;
bool flag = 0;
for (i; i < n; i++) {
flag = flag || (first[i] && second[i]);
}
if (flag) {
cout << "YES";
return 0;
}
cout << "NO";
}
``` |
### Prompt
Generate a cpp solution to the following problem:
While Mahmoud and Ehab were practicing for IOI, they found a problem which name was Longest common subsequence. They solved it, and then Ehab challenged Mahmoud with another problem.
Given two strings a and b, find the length of their longest uncommon subsequence, which is the longest string that is a subsequence of one of them and not a subsequence of the other.
A subsequence of some string is a sequence of characters that appears in the same order in the string, The appearances don't have to be consecutive, for example, strings "ac", "bc", "abc" and "a" are subsequences of string "abc" while strings "abbc" and "acb" are not. The empty string is a subsequence of any string. Any string is a subsequence of itself.
Input
The first line contains string a, and the second line β string b. Both of these strings are non-empty and consist of lowercase letters of English alphabet. The length of each string is not bigger than 105 characters.
Output
If there's no uncommon subsequence, print "-1". Otherwise print the length of the longest uncommon subsequence of a and b.
Examples
Input
abcd
defgh
Output
5
Input
a
a
Output
-1
Note
In the first example: you can choose "defgh" from string b as it is the longest subsequence of string b that doesn't appear as a subsequence of string a.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string s1, s2;
long long i, j, k, f1 = 0, f2 = 0, len1, len2, flg = 0;
cin >> s1 >> s2;
len1 = s1.size();
len2 = s2.size();
long long m = max(len1, len2);
for (i = 0; i < m; i++) {
if (s1[i] != s2[i]) {
flg++;
break;
}
}
if (flg != 0)
cout << m << endl;
else
cout << "-1" << endl;
return 0;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
Ivan had string s consisting of small English letters. However, his friend Julia decided to make fun of him and hid the string s. Ivan preferred making a new string to finding the old one.
Ivan knows some information about the string s. Namely, he remembers, that string ti occurs in string s at least ki times or more, he also remembers exactly ki positions where the string ti occurs in string s: these positions are xi, 1, xi, 2, ..., xi, ki. He remembers n such strings ti.
You are to reconstruct lexicographically minimal string s such that it fits all the information Ivan remembers. Strings ti and string s consist of small English letters only.
Input
The first line contains single integer n (1 β€ n β€ 105) β the number of strings Ivan remembers.
The next n lines contain information about the strings. The i-th of these lines contains non-empty string ti, then positive integer ki, which equal to the number of times the string ti occurs in string s, and then ki distinct positive integers xi, 1, xi, 2, ..., xi, ki in increasing order β positions, in which occurrences of the string ti in the string s start. It is guaranteed that the sum of lengths of strings ti doesn't exceed 106, 1 β€ xi, j β€ 106, 1 β€ ki β€ 106, and the sum of all ki doesn't exceed 106. The strings ti can coincide.
It is guaranteed that the input data is not self-contradictory, and thus at least one answer always exists.
Output
Print lexicographically minimal string that fits all the information Ivan remembers.
Examples
Input
3
a 4 1 3 5 7
ab 2 1 5
ca 1 4
Output
abacaba
Input
1
a 1 3
Output
aaa
Input
3
ab 1 1
aba 1 3
ab 2 3 5
Output
ababab
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n;
string a[100005];
set<int> b;
pair<int, int> c[2000005];
void mark(int l, int r, int i) {
while (1) {
auto it = b.lower_bound(l);
if (it == b.end() || *it > r) break;
c[*it] = {i, *it - l};
b.erase(it);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cerr.tie(nullptr);
int n, h = 0;
cin >> n;
for (int i = 1; i <= 2000000; i++) b.insert(i);
for (int i = 1; i <= n; i++) {
cin >> a[i];
int t;
cin >> t;
while (t--) {
int x;
cin >> x;
int r = x + a[i].size() - 1;
mark(x, r, i);
h = max(h, r);
}
}
for (int i = 1; i <= h; i++) {
if (c[i].first == 0)
cout << 'a';
else
cout << a[c[i].first][c[i].second];
}
cout << '\n';
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
Let a and b be some non-negative integers. Let's define strange addition of a and b as following:
1. write down the numbers one under another and align them by their least significant digit;
2. add them up digit by digit and concatenate the respective sums together.
Assume that both numbers have an infinite number of leading zeros.
For example, let's take a look at a strange addition of numbers 3248 and 908:
<image>
You are given a string c, consisting of n digits from 0 to 9. You are also given m updates of form:
* x~d β replace the digit at the x-th position of c with a digit d.
Note that string c might have leading zeros at any point of time.
After each update print the number of pairs (a, b) such that both a and b are non-negative integers and the result of a strange addition of a and b is equal to c.
Note that the numbers of pairs can be quite large, so print them modulo 998244353.
Input
The first line contains two integers n and m (1 β€ n, m β€ 5 β
10^5) β the length of the number c and the number of updates.
The second line contains a string c, consisting of exactly n digits from 0 to 9.
Each of the next m lines contains two integers x and d (1 β€ x β€ n, 0 β€ d β€ 9) β the descriptions of updates.
Output
Print m integers β the i-th value should be equal to the number of pairs (a, b) such that both a and b are non-negative integers and the result of a strange addition of a and b is equal to c after i updates are applied.
Note that the numbers of pairs can be quite large, so print them modulo 998244353.
Example
Input
2 3
14
2 4
2 1
1 0
Output
15
12
2
Note
After the first update c is equal to 14. The pairs that sum up to 14 are: (0, 14), (1, 13), (2, 12), (3, 11), (4, 10), (5, 9), (6, 8), (7, 7), (8, 6), (9, 5), (10, 4), (11, 3), (12, 2), (13, 1), (14, 0).
After the second update c is equal to 11.
After the third update c is equal to 01.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct P {
long long x, y = 1, z, v = 1, a = 0;
bool operator<(const P &a) const { return x < a.x; };
};
int a, b, c, d, i, n, m, e, k, dx[10] = {1, 0, -1, 0, 1, 1, -1, -1},
dy[10] = {0, 1, 0, -1, 1, -1, 1, -1};
int o[501015];
int l[1];
int ss[1];
long long x, y, z, mod = 998244353;
char r[1];
vector<int> v[1];
P u[1200011];
queue<P> q;
stack<int> s;
map<int, int> p;
bool as(P a, P b) {
if (a.x != b.x) return a.x < b.x;
return a.y < b.y;
}
P g(P n, P m) {
if (n.z < 0) return m;
if (m.z < 0) return n;
P s;
s.z = n.z;
s.x = n.x * m.x % mod;
s.x += n.y * m.z % mod * m.v % mod;
s.x %= mod;
s.y = (n.x * m.y % mod + n.y * m.z % mod * m.a % mod) % mod;
s.v = (n.v * m.x % mod + n.a * m.z % mod * m.v % mod) % mod;
s.a = (n.v * m.y % mod + n.a * m.z % mod * m.a % mod) % mod;
return s;
}
P f(int n, int m) {
P s1, s2;
s1.z = s2.z = -1;
for (; n < m;) {
if (n % 2)
s1 = g(s1, u[n]), n++;
else if (m % 2 == 0)
s2 = g(u[m], s2), m--;
else
n /= 2, m /= 2;
}
return g(g(s1, u[n]), s2);
}
int main() {
scanf("%d %d", &a, &b);
for (int t = 1; t <= a; t++) scanf("%1d", &o[t]);
o[0] = 123;
for (i = 1; i < a; i *= 2)
;
for (int t = 1; t <= a; t++) {
u[t + i - 1].x = o[t] + 1;
if (o[t - 1] == 1 && o[t] < 9) u[t + i - 1].z = 9 - (o[t] + 10 - 9) + 1;
}
for (int t = i - 1; t; t--) u[t] = g(u[t * 2], u[t * 2 + 1]);
for (int t = 1; t <= b; t++) {
scanf("%d %d", &n, &m);
o[n] = m;
u[n + i - 1].x = o[n] + 1;
if (o[n - 1] == 1 && o[n] < 9)
u[n + i - 1].z = 9 - (o[n] + 10 - 9) + 1;
else
u[n + i - 1].z = 0;
for (int h = (n + i - 1) / 2; h; h /= 2) u[h] = g(u[h * 2], u[h * 2 + 1]);
if (n < a && o[n] == 1 && o[n + 1] < 9)
u[n + i].z = 9 - (o[n + 1] + 10 - 9) + 1;
else if (n < a)
u[n + i].z = 0;
if (n < a)
for (int h = (n + i) / 2; h; h /= 2) u[h] = g(u[h * 2], u[h * 2 + 1]);
printf("%lld\n", f(i, i + a - 1).x);
}
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
Vasya owns a cornfield which can be defined with two integers n and d. The cornfield can be represented as rectangle with vertices having Cartesian coordinates (0, d), (d, 0), (n, n - d) and (n - d, n).
<image> An example of a cornfield with n = 7 and d = 2.
Vasya also knows that there are m grasshoppers near the field (maybe even inside it). The i-th grasshopper is at the point (x_i, y_i). Vasya does not like when grasshoppers eat his corn, so for each grasshopper he wants to know whether its position is inside the cornfield (including the border) or outside.
Help Vasya! For each grasshopper determine if it is inside the field (including the border).
Input
The first line contains two integers n and d (1 β€ d < n β€ 100).
The second line contains a single integer m (1 β€ m β€ 100) β the number of grasshoppers.
The i-th of the next m lines contains two integers x_i and y_i (0 β€ x_i, y_i β€ n) β position of the i-th grasshopper.
Output
Print m lines. The i-th line should contain "YES" if the position of the i-th grasshopper lies inside or on the border of the cornfield. Otherwise the i-th line should contain "NO".
You can print each letter in any case (upper or lower).
Examples
Input
7 2
4
2 4
4 1
6 3
4 5
Output
YES
NO
NO
YES
Input
8 7
4
4 4
2 8
8 1
6 1
Output
YES
NO
YES
YES
Note
The cornfield from the first example is pictured above. Grasshoppers with indices 1 (coordinates (2, 4)) and 4 (coordinates (4, 5)) are inside the cornfield.
The cornfield from the second example is pictured below. Grasshoppers with indices 1 (coordinates (4, 4)), 3 (coordinates (8, 1)) and 4 (coordinates (6, 1)) are inside the cornfield.
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
std::string IntToStr(int x) {
std::string str;
while (x != 0) {
str += x % 10 + '0';
x = x / 10;
}
std::reverse(str.begin(), str.end());
return str;
}
int StrToInt(std::string str) {
int rez = 0;
std::string str2 = str;
if (!str.empty()) {
if (str[0] == '-') str2 = str.substr(1);
for (int i = 0; i < str2.size(); i++) {
if (str2[i] >= '0' && str2[i] <= '9')
rez = rez * 10 + str2[i] - '0';
else
return -1;
}
if (str[0] == '-') rez *= -1;
}
return rez;
}
std::string ToLower(std::string str) {
for (int i = 0; i < str.size(); i++) {
if (str[i] >= 'A' && str[i] <= 'Z') str[i] = str[i] - 'A' + 'a';
}
return str;
}
std::vector<std::string> Split(std::string str, char parser = ' ') {
std::vector<std::string> rez;
while (str.find(parser) != -1) {
int p = str.find(parser);
rez.push_back(str.substr(0, p));
str = str.substr(p + 1);
}
rez.push_back(str);
return rez;
}
int MaxInVec(std::vector<int> v) {
int rez = v[0];
for (int i = 0; i < v.size(); i++)
if (v[i] > rez) rez = v[i];
return rez;
}
int MinInVec(std::vector<int> v) {
int rez = v[0];
for (int i = 0; i < v.size(); i++)
if (v[i] < rez) rez = v[i];
return rez;
}
long MinInLongVec(std::vector<long> v) {
long rez = v[0];
for (int i = 0; i < v.size(); i++)
if (v[i] < rez) rez = v[i];
return rez;
}
int SumInVec(std::vector<int> v) {
int rez = 0;
for (int i = 0; i < v.size(); i++) rez += v[i];
return rez;
}
int FindInt(std::vector<int> v, int x) {
for (int i = 0; i < v.size(); i++)
if (v[i] == x) return i;
return -1;
}
int FindString(std::vector<std::string> v, std::string x) {
for (int i = 0; i < v.size(); i++)
if (v[i] == x) return i;
return -1;
}
void PrintIntVec(std::vector<int> v) {
for (int i = 0; i < v.size(); i++) {
std::cout << v[i] << " ";
}
std::cout << std::endl;
}
bool IsLetter(char c) {
if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')) return true;
return false;
}
int main() {
int n, d;
cin >> n >> d;
vector<pair<int, int>> ver(4);
ver[0] = make_pair(0, d);
ver[1] = make_pair(d, 0);
ver[2] = make_pair(n, n - d);
ver[3] = make_pair(n - d, n);
int m;
cin >> m;
vector<pair<int, int>> kuz(m);
for (int i = 0; i < m; i++) {
cin >> kuz[i].first >> kuz[i].second;
}
for (int i = 0; i < m; i++) {
float angle = 0.0f;
for (int j = 0; j < 4; j++) {
pair<int, int> p1;
p1.first = ver[j].first - kuz[i].first;
p1.second = ver[j].second - kuz[i].second;
pair<int, int> p2;
if (j != 3) {
p2.first = ver[j + 1].first - kuz[i].first;
p2.second = ver[j + 1].second - kuz[i].second;
} else {
p2.first = ver[0].first - kuz[i].first;
p2.second = ver[0].second - kuz[i].second;
}
float co = (p1.first * p2.first + p1.second * p2.second) /
(sqrt(pow(p1.first, 2) + pow(p1.second, 2)) *
sqrt(pow(p2.first, 2) + pow(p2.second, 2)));
angle += acos(co);
}
if (abs(angle - 2 * 3.1415926535) < 0.0001f ||
(kuz[i] == ver[0] || kuz[i] == ver[1] || kuz[i] == ver[2] ||
kuz[i] == ver[3])) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
Write a program which calculates the area and circumference of a circle for given radius r.
Constraints
* 0 < r < 10000
Input
A real number r is given.
Output
Print the area and circumference of the circle in a line. Put a single space between them. The output should not contain an absolute error greater than 10-5.
Examples
Input
2
Output
12.566371 12.566371
Input
3
Output
28.274334 18.849556
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
double r;
cin>>r;
printf("%.6f %.6f\n",r*r*M_PI,2.0*r*M_PI);
return 0;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
You must have heard of the two brothers dreaming of ruling the world. With all their previous plans failed, this time they decided to cooperate with each other in order to rule the world.
As you know there are n countries in the world. These countries are connected by n - 1 directed roads. If you don't consider direction of the roads there is a unique path between every pair of countries in the world, passing through each road at most once.
Each of the brothers wants to establish his reign in some country, then it's possible for him to control the countries that can be reached from his country using directed roads.
The brothers can rule the world if there exists at most two countries for brothers to choose (and establish their reign in these countries) so that any other country is under control of at least one of them. In order to make this possible they want to change the direction of minimum number of roads. Your task is to calculate this minimum number of roads.
Input
The first line of input contains an integer n (1 β€ n β€ 3000). Each of the next n - 1 lines contains two space-separated integers ai and bi (1 β€ ai, bi β€ n; ai β bi) saying there is a road from country ai to country bi.
Consider that countries are numbered from 1 to n. It's guaranteed that if you don't consider direction of the roads there is a unique path between every pair of countries in the world, passing through each road at most once.
Output
In the only line of output print the minimum number of roads that their direction should be changed so that the brothers will be able to rule the world.
Examples
Input
4
2 1
3 1
4 1
Output
1
Input
5
2 1
2 3
4 3
4 5
Output
0
### Response
```cpp
#include <bits/stdc++.h>
const int MAXN = 3100;
const int INF = 0x7F7F7F7F;
struct Tedge {
int p, f, next;
};
int n;
int a[MAXN];
int f[MAXN], fv[MAXN];
int q[MAXN];
int dp0[MAXN], dp1[MAXN], dp2[MAXN];
Tedge edge[MAXN * 2];
int min(int x, int y) { return x < y ? x : y; }
void init() {
scanf("%d", &n);
int i, u, v, l = 0;
memset(a, 0xff, sizeof(a));
for (i = 1; i < n; ++i) {
scanf("%d %d", &u, &v);
edge[++l].p = v;
edge[l].f = 0;
edge[l].next = a[u];
a[u] = l;
edge[++l].p = u;
edge[l].f = 1;
edge[l].next = a[v];
a[v] = l;
}
}
int solve(int root) {
int i, ii, k, st = 0, ed = 1;
memset(f, 0xff, sizeof(f));
f[root] = 0;
q[1] = root;
while (st < ed) {
k = q[++st];
for (i = a[k]; i != -1; i = edge[i].next)
if (f[edge[i].p] == -1) {
f[edge[i].p] = k;
fv[edge[i].p] = edge[i].f;
q[++ed] = edge[i].p;
}
}
memset(dp0, 0, sizeof(dp0));
memset(dp1, 0x7F, sizeof(dp0));
memset(dp2, 0x7F, sizeof(dp0));
for (ii = n; ii > 1; --ii) {
k = q[ii];
dp0[f[k]] += dp0[k] + fv[k];
}
for (ii = n; ii > 1; --ii) {
k = q[ii];
if (dp1[k] == INF) dp1[k] = 0;
if (dp2[k] == INF) dp2[k] = 0;
dp1[f[k]] = min(dp1[f[k]], min(dp1[k], dp0[k]) + dp0[f[k]] - dp0[k] -
fv[k] + 1 - fv[k]);
dp2[f[k]] =
min(dp2[f[k]], min(min(dp2[k], dp1[k]), dp0[k]) + dp0[f[k]] - dp0[k]);
}
return min(dp0[root], min(dp1[root], dp2[root]));
}
int main() {
init();
int ans = INF;
for (int i = 1; i <= n; ++i) ans = min(ans, solve(i));
printf("%d\n", ans);
return 0;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
Let's define the cost of a string s as the number of index pairs i and j (1 β€ i < j < |s|) such that s_i = s_j and s_{i+1} = s_{j+1}.
You are given two positive integers n and k. Among all strings with length n that contain only the first k characters of the Latin alphabet, find a string with minimum possible cost. If there are multiple such strings with minimum cost β find any of them.
Input
The only line contains two integers n and k (1 β€ n β€ 2 β
10^5; 1 β€ k β€ 26).
Output
Print the string s such that it consists of n characters, each its character is one of the k first Latin letters, and it has the minimum possible cost among all these strings. If there are multiple such strings β print any of them.
Examples
Input
9 4
Output
aabacadbb
Input
5 1
Output
aaaaa
Input
10 26
Output
codeforces
### Response
```cpp
#pragma GCC optimize(2)
#include <bits/stdc++.h>
#define IOS std::ios_base::sync_with_stdio(false), std::cin.tie(0), std::cout.tie(0);
using namespace std;
int n, k;
string bs, ans;
signed main() {
IOS
cin >> n >> k;
for(int i = 0;i < k;++i) {
bs += 'a' + i;
for(int j = i + 1;j < k;++j) {
bs += 'a' + i;
bs += 'a' + j;
}
}
ans = bs;
while(ans.size() < n) {
ans += bs;
}
cout << ans.substr(0, n) << "\n";
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
The educational program (AHK Education) of the Aiz Broadcasting Corporation broadcasts a program called "Play with Tsukuro" for children. Today is the time to make a box with drawing paper, but I would like to see if the rectangular drawing paper I prepared can make a rectangular parallelepiped. However, do not cut or fold the drawing paper.
Given six rectangles, write a program to determine if you can make a rectangular parallelepiped using them.
Input
The input is given in the following format.
h1 w1
h2 w2
h3 w3
h4 w4
h5 w5
h6 w6
The input consists of 6 lines, each line given the integer hi (1 β€ hi β€ 1000) for the vertical length of each rectangle and the integer wi (1 β€ wi β€ 1000) for the horizontal length.
Output
If a rectangular parallelepiped can be created, "yes" is output, and if it cannot be created, "no" is output. However, since a cube is a kind of rectangular parallelepiped, "yes" is output even if it is a cube.
Examples
Input
2 2
2 3
2 3
2 3
2 2
3 2
Output
yes
Input
2 2
2 3
2 3
2 3
2 2
2 2
Output
no
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct rect{
int h,w;
};
bool operator<(rect r1, rect r2){
if(r1.w == r2.w){
return r1.h > r2.h;
}
return r1.w > r2.w;
}
int main() {
rect r[6];
for(int i=0;i<6;i++) {
cin >> r[i].h >> r[i].w;
if (r[i].h > r[i].w) {
swap(r[i].h, r[i].w);
}
}
sort(r,r+6);
/*if(r[0].w != r[2].w && r[2].w == r[5].w){
swap(r[0],r[4]);
swap(r[1],r[5]);
}*/
/*for(int i=0;i<6;i++) {
cout << r[i].w << " " << r[i].h << endl;
}*/
if(r[0].h == r[1].h && r[0].w == r[1].w && r[2].h == r[3].h && r[2].w == r[3].w && r[4].h == r[5].h && r[4].w == r[5].w && r[0].w == r[2].w && r[2].h == r[4].h && r[0].h == r[4].w){
cout << "yes" << endl;
}
else{
cout << "no" << endl;
}
// x1=x2,y1=y3,y2=x3;
return 0;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
We're giving away nice huge bags containing number tiles! A bag we want to present to you contains n tiles. Each of them has a single number written on it β either 1 or 2.
However, there is one condition you must fulfill in order to receive the prize. You will need to put all the tiles from the bag in a sequence, in any order you wish. We will then compute the sums of all prefixes in the sequence, and then count how many of these sums are prime numbers. If you want to keep the prize, you will need to maximize the number of primes you get.
Can you win the prize? Hurry up, the bags are waiting!
Input
The first line of the input contains a single integer n (1 β€ n β€ 200 000) β the number of number tiles in the bag. The following line contains n space-separated integers a_1, a_2, ..., a_n (a_i β \{1, 2\}) β the values written on the tiles.
Output
Output a permutation b_1, b_2, ..., b_n of the input sequence (a_1, a_2, ..., a_n) maximizing the number of the prefix sums being prime numbers. If there are multiple optimal permutations, output any.
Examples
Input
5
1 2 1 2 1
Output
1 1 1 2 2
Input
9
1 1 2 1 1 1 2 1 1
Output
1 1 1 2 1 1 1 2 1
Note
The first solution produces the prefix sums 1, \mathbf{\color{blue}{2}}, \mathbf{\color{blue}{3}}, \mathbf{\color{blue}{5}}, \mathbf{\color{blue}{7}} (four primes constructed), while the prefix sums in the second solution are 1, \mathbf{\color{blue}{2}}, \mathbf{\color{blue}{3}}, \mathbf{\color{blue}{5}}, 6, \mathbf{\color{blue}{7}}, 8, 10, \mathbf{\color{blue}{11}} (five primes). Primes are marked bold and blue. In each of these cases, the number of produced primes is maximum possible.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
signed main() {
long long n;
cin >> n;
long long c1 = 0;
long long c2 = 0;
for (long long i = 0; i < n; ++i) {
long long a;
cin >> a;
if (a == 1) {
++c1;
} else {
++c2;
}
}
long long s = c1 + 2 * c2 + 1;
vector<bool> A(s + 1, true);
for (long long i = 2; i * i <= s; ++i) {
if (A[i]) {
for (long long j = i * i; j <= s; j += i) {
A[j] = false;
}
}
}
vector<long long> prime;
for (long long i = 2; i < s + 1; ++i) {
if (A[i]) {
prime.push_back(i);
}
}
long long sum = 0;
long long it = 0;
long long fi = c1 + c2;
for (long long i = 0; i < fi; ++i) {
if (c2 != 0 && sum + 2 <= prime[it]) {
cout << "2 ";
sum += 2;
--c2;
} else if (c1 != 0 && sum + 1 <= prime[it]) {
cout << "1 ";
sum += 1;
--c1;
}
if (sum == prime[it]) {
++it;
}
}
while (c1 != 0) {
cout << "1 ";
--c1;
}
while (c2 != 0) {
cout << "2 ";
--c2;
}
return 0;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
You know that Japan is the country with almost the largest 'electronic devices per person' ratio. So you might be quite surprised to find out that the primary school in Japan teaches to count using a Soroban β an abacus developed in Japan. This phenomenon has its reasons, of course, but we are not going to speak about them. Let's have a look at the Soroban's construction.
<image>
Soroban consists of some number of rods, each rod contains five beads. We will assume that the rods are horizontal lines. One bead on each rod (the leftmost one) is divided from the others by a bar (the reckoning bar). This single bead is called go-dama and four others are ichi-damas. Each rod is responsible for representing a single digit from 0 to 9. We can obtain the value of a digit by following simple algorithm:
* Set the value of a digit equal to 0.
* If the go-dama is shifted to the right, add 5.
* Add the number of ichi-damas shifted to the left.
Thus, the upper rod on the picture shows digit 0, the middle one shows digit 2 and the lower one shows 7. We will consider the top rod to represent the last decimal digit of a number, so the picture shows number 720.
Write the program that prints the way Soroban shows the given number n.
Input
The first line contains a single integer n (0 β€ n < 109).
Output
Print the description of the decimal digits of number n from the last one to the first one (as mentioned on the picture in the statement), one per line. Print the beads as large English letters 'O', rod pieces as character '-' and the reckoning bar as '|'. Print as many rods, as many digits are in the decimal representation of number n without leading zeroes. We can assume that number 0 has no leading zeroes.
Examples
Input
2
Output
O-|OO-OO
Input
13
Output
O-|OOO-O
O-|O-OOO
Input
720
Output
O-|-OOOO
O-|OO-OO
-O|OO-OO
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string a[10];
a[0] = "O-|-OOOO";
a[1] = "O-|O-OOO";
a[2] = "O-|OO-OO";
a[3] = "O-|OOO-O";
a[4] = "O-|OOOO-";
a[5] = "-O|-OOOO";
a[6] = "-O|O-OOO";
a[7] = "-O|OO-OO";
a[8] = "-O|OOO-O";
a[9] = "-O|OOOO-";
cout << a[n % 10];
n /= 10;
while (n > 0) {
cout << endl << a[n % 10];
n /= 10;
}
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.
Find the total number of biscuits produced within T + 0.5 seconds after activation.
Constraints
* All values in input are integers.
* 1 \leq A, B, T \leq 20
Input
Input is given from Standard Input in the following format:
A B T
Output
Print the total number of biscuits produced within T + 0.5 seconds after activation.
Examples
Input
3 5 7
Output
10
Input
3 2 9
Output
6
Input
20 20 19
Output
0
### Response
```cpp
#include <iostream>
using namespace std;
int main(){
int A,B,T;
cin >> A >> B >> T;
cout << int(T/A)*B << endl;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
Examples
Input
4 5 2
0 1 2 1
0 2 1 2
1 2 1 1
1 3 1 3
2 3 2 1
Output
6
Input
Output
### Response
```cpp
//#define __USE_MINGW_ANSI_STDIO 0
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<ll> VL;
typedef vector<VL> VVL;
typedef pair<int, int> PII;
#define FOR(i, a, n) for (ll i = (ll)a; i < (ll)n; ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(x) x.begin(), x.end()
#define IN(a, b, x) (a<=x&&x<b)
#define MP make_pair
#define PB push_back
const int INF = (1LL<<30);
const ll LLINF = (1LL<<60);
const double PI = 3.14159265359;
const double EPS = 1e-12;
const int MOD = 1000000007;
//#define int ll
template <typename T> T &chmin(T &a, const T &b) { return a = min(a, b); }
template <typename T> T &chmax(T &a, const T &b) { return a = max(a, b); }
int dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0};
#define MAX_V 10000
struct edge { int to, cap, cost, rev; };
int V;
vector<edge> G[MAX_V];
int h[MAX_V];
int dist[MAX_V];
int prevv[MAX_V], preve[MAX_V];
void add_edge(int from, int to, int cap, int cost) {
G[from].PB({to, cap, cost, (int)G[to].size()});
G[to].PB({from, 0, -cost, (int)G[from].size()-1});
}
// s??????t????????????f???????Β°??????Β¨???
int min_cost_flow(int s, int t, int f) {
int res = 0;
fill(h, h+V, 0);
while(f > 0) {
priority_queue<PII, vector<PII>, greater<PII>> que;
fill(dist, dist+V, INF);
dist[s] = 0;
que.push({0, s});
while(que.size()) {
PII p = que.top(); que.pop();
int v = p.second;
if(dist[v] < p.first) continue;
for(int i=0; i<(int)G[v].size(); ++i) {
edge &e = G[v][i];
if(e.cap > 0 && dist[e.to] > dist[v] + e.cost + h[v] - h[e.to]) {
dist[e.to] = dist[v] + e.cost + h[v] - h[e.to];
prevv[e.to] = v;
preve[e.to] = i;
que.push({dist[e.to], e.to});
}
}
}
// ????????\???????????????
if(dist[t] == INF) return -1;
REP(v, V) h[v] += dist[v];
int d = f;
for(int v = t; v != s; v = prevv[v]) {
d = min(d, G[prevv[v]][preve[v]].cap);
}
f -= d;
res += d * h[t];
for(int v = t; v != s; v = prevv[v]) {
edge &e = G[prevv[v]][preve[v]];
e.cap -= d;
G[v][e.rev].cap += d;
}
}
return res;
}
signed main(void)
{
int e, f;
cin >> V >> e >> f;
REP(i, e) {
int u, v, c, d;
cin >> u >> v >> c >> d;
add_edge(u, v, c, d);
}
cout << min_cost_flow(0, V-1, f) << endl;
return 0;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
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 <bits/stdc++.h>
using namespace std;
const int MOD = 1e4;
int n;
int ng[101][4];
int dp[101][4][4];
int search(int i, int a, int b)
{
int &res = dp[i][a][b];
if (~res) return res;
if (ng[i][b]) return res = 0;
if (i == n) return res = 1;
res = 0;
for (int ne = 1; ne <= 3; ne++){
if (a == b && b == ne) continue;
res += search(i + 1, b, ne);
res %= MOD;
}
return res;
}
int main()
{
memset(dp, -1, sizeof(dp));
int k;
scanf("%d %d", &n, &k);
for (int i = 0; i < k; i++){
int a, b;
scanf("%d %d", &a, &b);
ng[a][(b + 1) % 3 + 1] = true;
ng[a][b % 3 + 1] = true;
}
int res = search(0, 0, 0);
printf("%d\n", res);
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
"Multidimensional spaces are completely out of style these days, unlike genetics problems" β thought physicist Woll and changed his subject of study to bioinformatics. Analysing results of sequencing he faced the following problem concerning DNA sequences. We will further think of a DNA sequence as an arbitrary string of uppercase letters "A", "C", "G" and "T" (of course, this is a simplified interpretation).
Let w be a long DNA sequence and s1, s2, ..., sm β collection of short DNA sequences. Let us say that the collection filters w iff w can be covered with the sequences from the collection. Certainly, substrings corresponding to the different positions of the string may intersect or even cover each other. More formally: denote by |w| the length of w, let symbols of w be numbered from 1 to |w|. Then for each position i in w there exist pair of indices l, r (1 β€ l β€ i β€ r β€ |w|) such that the substring w[l ... r] equals one of the elements s1, s2, ..., sm of the collection.
Woll wants to calculate the number of DNA sequences of a given length filtered by a given collection, but he doesn't know how to deal with it. Help him! Your task is to find the number of different DNA sequences of length n filtered by the collection {si}.
Answer may appear very large, so output it modulo 1000000009.
Input
First line contains two integer numbers n and m (1 β€ n β€ 1000, 1 β€ m β€ 10) β the length of the string and the number of sequences in the collection correspondently.
Next m lines contain the collection sequences si, one per line. Each si is a nonempty string of length not greater than 10. All the strings consist of uppercase letters "A", "C", "G", "T". The collection may contain identical strings.
Output
Output should contain a single integer β the number of strings filtered by the collection modulo 1000000009 (109 + 9).
Examples
Input
2 1
A
Output
1
Input
6 2
CAT
TACT
Output
2
Note
In the first sample, a string has to be filtered by "A". Clearly, there is only one such string: "AA".
In the second sample, there exist exactly two different strings satisfying the condition (see the pictures below).
<image> <image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct Node {
Node *go[26];
bool leaf;
Node *link;
Node *anc;
char to_anc;
Node *clink;
int depth;
Node() {
leaf = false;
link = nullptr;
anc = nullptr;
clink = nullptr;
depth = 0;
}
} t[1010];
Node *root = t;
int tree_size = 1;
Node *go(Node *v, char c);
Node *link(Node *v);
Node *clink(Node *v);
Node *go(Node *v, char c) {
if (v->go[c] == nullptr) {
if (v == root) return v->go[c] = root;
return v->go[c] = go(link(v), c);
}
return v->go[c];
}
Node *link(Node *v) {
if (v->link == nullptr) {
if (v == root || v->anc == root) return v->link = root;
return v->link = go(link(v->anc), v->to_anc);
}
return v->link;
}
Node *clink(Node *v) {
if (v->clink == nullptr) {
if (v == root) return v->clink = root;
if (link(v)->leaf) return v->clink = v->link;
return v->clink = clink(v->link);
}
return v->clink;
}
void add(Node *v, Node *to, char c) {
v->go[c] = to;
to->anc = v;
to->to_anc = c;
to->depth = v->depth + 1;
}
int maxD(Node *v) {
if (v->leaf) return v->depth;
if (v == root) return 0;
return clink(v)->depth;
}
void add(const string &s) {
Node *v = root;
for (char ch : s) {
int c = ch - 'A';
if (v->go[c] == nullptr) {
add(v, t + tree_size, c);
++tree_size;
}
v = v->go[c];
}
v->leaf = true;
}
int n, m;
int d[1010][13], h[1010][13];
void read() {
cin >> n >> m;
for (int i = 0; i < m; ++i) {
string s;
cin >> s;
add(s);
}
}
void next(int x, int y, char c, int &tx, int &ty) {
tx = (int)(go(t + x, c) - t);
ty = y + 1;
int d = maxD(t + tx);
if (d >= ty) ty = 0;
}
void din_step() {
for (int i = 0; i < tree_size; ++i)
for (int j = 0; j < 13; ++j)
if (d[i][j]) {
int tx, ty;
for (int k = 0; k < 26; ++k) {
next(i, j, k, tx, ty);
if (ty >= 13) continue;
h[tx][ty] += d[i][j];
if (h[tx][ty] >= 1000000009) h[tx][ty] -= 1000000009;
}
}
for (int i = 0; i < tree_size; ++i)
for (int j = 0; j < 13; ++j) {
d[i][j] = h[i][j];
h[i][j] = 0;
}
}
int main() {
read();
d[0][0] = 1;
for (int i = 0; i < n; ++i) din_step();
int ans = 0;
for (int i = 0; i < tree_size; ++i) {
ans += d[i][0];
if (ans >= 1000000009) ans -= 1000000009;
}
cout << ans << "\n";
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
You are given string s of length n consisting of 0-s and 1-s. You build an infinite string t as a concatenation of an infinite number of strings s, or t = ssss ... For example, if s = 10010, then t = 100101001010010...
Calculate the number of prefixes of t with balance equal to x. The balance of some string q is equal to cnt_{0, q} - cnt_{1, q}, where cnt_{0, q} is the number of occurrences of 0 in q, and cnt_{1, q} is the number of occurrences of 1 in q. The number of such prefixes can be infinite; if it is so, you must say that.
A prefix is a string consisting of several first letters of a given string, without any reorders. An empty prefix is also a valid prefix. For example, the string "abcd" has 5 prefixes: empty string, "a", "ab", "abc" and "abcd".
Input
The first line contains the single integer T (1 β€ T β€ 100) β the number of test cases.
Next 2T lines contain descriptions of test cases β two lines per test case. The first line contains two integers n and x (1 β€ n β€ 10^5, -10^9 β€ x β€ 10^9) β the length of string s and the desired balance, respectively.
The second line contains the binary string s (|s| = n, s_i β \{0, 1\}).
It's guaranteed that the total sum of n doesn't exceed 10^5.
Output
Print T integers β one per test case. For each test case print the number of prefixes or -1 if there is an infinite number of such prefixes.
Example
Input
4
6 10
010010
5 3
10101
1 0
0
2 0
01
Output
3
0
1
-1
Note
In the first test case, there are 3 good prefixes of t: with length 28, 30 and 32.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n, x;
cin >> n >> x;
string s;
cin >> s;
int bal[n];
int cnt = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '0')
cnt++;
else
cnt--;
bal[i] = cnt;
}
if (bal[n - 1] == 0) {
int flag = 0;
for (int i = 0; i < n; i++) {
if (bal[i] == x) {
flag = 1;
cout << -1 << endl;
break;
}
}
if (flag == 0) cout << (x == 0) << endl;
continue;
}
int ans = 0;
if (x == 0) ans++;
for (int i = 0; i < n; i++)
if ((x - bal[i]) % cnt == 0 && (x - bal[i]) / cnt >= 0) ans++;
cout << ans << endl;
}
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
Welcome to PC Koshien, players. At PC Koshien, competitions are currently being held in a total of three categories: programming category, mobile category, and Ichimai's picture CG category.
Given the number of participants in each department, create a program that calculates the total number of participants.
Input
The input is given in the following format.
p m c
The input is one line, the number of participants in the programming department p (0 β€ p β€ 10000), the number of participants in the mobile department m (0 β€ m β€ 10000), the number of participants in the Ichimai picture CG department c (0) β€ c β€ 10000) is given.
Output
Output the total number of participants on one line.
Examples
Input
10 10 20
Output
40
Input
100 0 0
Output
100
Input
1000 1000 1000
Output
3000
### Response
```cpp
#include <iostream>
using namespace std;;
int main(){
int p,m,c;
cin>>p>>m>>c;
int A = p+m+c;
cout<<A<<endl;
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
PolandBall is a young, clever Ball. He is interested in prime numbers. He has stated a following hypothesis: "There exists such a positive integer n that for each positive integer m number nΒ·m + 1 is a prime number".
Unfortunately, PolandBall is not experienced yet and doesn't know that his hypothesis is incorrect. Could you prove it wrong? Write a program that finds a counterexample for any n.
Input
The only number in the input is n (1 β€ n β€ 1000) β number from the PolandBall's hypothesis.
Output
Output such m that nΒ·m + 1 is not a prime number. Your answer will be considered correct if you output any suitable m such that 1 β€ m β€ 103. It is guaranteed the the answer exists.
Examples
Input
3
Output
1
Input
4
Output
2
Note
A prime number (or a prime) is a natural number greater than 1 that has no positive divisors other than 1 and itself.
For the first sample testcase, 3Β·1 + 1 = 4. We can output 1.
In the second sample testcase, 4Β·1 + 1 = 5. We cannot output 1 because 5 is prime. However, m = 2 is okay since 4Β·2 + 1 = 9, which is not a prime number.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n;
cin >> n;
vector<bool> p(pow(10, 6) + 1, 0);
for (long long i = 2; i <= pow(10, 6); i++) {
if (p[i] == 0) {
for (long long j = i + i; j <= pow(10, 6); j += i) {
p[j] = 1;
}
}
}
if (n % 2 != 0) {
cout << 3;
} else {
for (long long i = 1; i <= 1000; i++) {
if (p[(n * i) + 1] == 1) {
cout << i;
exit(0);
}
}
}
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.