text
stringlengths 424
69.5k
|
|---|
### Prompt
Develop a solution in cpp to the problem described below:
JOI has a stove in your room. JOI himself is resistant to the cold, so he doesn't need to put on the stove when he is alone in the room, but he needs to put on the stove when there are visitors.
On this day, there are N guests under JOI. The ith (1 \ leq i \ leq N) visitor arrives at time T_i and leaves at time T_i + 1. There can never be more than one visitor at the same time.
JOI can turn the stove on and off at any time. However, each time you turn on the stove, you will consume one match. JOI has only K matches, so he can only stove up to K times. The stove is gone at the beginning of the day.
When the stove is on, fuel is consumed by that amount, so I want to set the time when the stove is on and off and minimize the total time when the stove is on.
Example
Input
3 2
1
3
6
Output
4
### Response
```cpp
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main(){
int N, K;
cin >> N >> K;
vector<int> T(N);
for(int i = 0; i < N; ++i){
cin >> T[i];
}
vector<int> R;
for(int i = 1; i < N; ++i){
R.push_back(T[i]-T[i-1]-1);
}
sort(R.rbegin(), R.rend());
int ans = T[N-1] + 1 - T[0];
for(int i = 0; i < K-1; ++i) ans -= R[i];
cout << ans << endl;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
You have three tasks, all of which need to be completed.
First, you can complete any one task at cost 0.
Then, just after completing the i-th task, you can complete the j-th task at cost |A_j - A_i|.
Here, |x| denotes the absolute value of x.
Find the minimum total cost required to complete all the task.
Constraints
* All values in input are integers.
* 1 \leq A_1, A_2, A_3 \leq 100
Input
Input is given from Standard Input in the following format:
A_1 A_2 A_3
Output
Print the minimum total cost required to complete all the task.
Examples
Input
1 6 3
Output
5
Input
11 5 5
Output
6
Input
100 100 100
Output
0
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main() {
int a[3];
cin >> a[0] >> a[1] >> a[2];
sort(begin(a), end(a));
cout << a[2] - a[0] << endl;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
You have A 500-yen coins, B 100-yen coins and C 50-yen coins (yen is the currency of Japan). In how many ways can we select some of these coins so that they are X yen in total?
Coins of the same kind cannot be distinguished. Two ways to select coins are distinguished when, for some kind of coin, the numbers of that coin are different.
Constraints
* 0 \leq A, B, C \leq 50
* A + B + C \geq 1
* 50 \leq X \leq 20 000
* A, B and C are integers.
* X is a multiple of 50.
Input
Input is given from Standard Input in the following format:
A
B
C
X
Output
Print the number of ways to select coins.
Examples
Input
2
2
2
100
Output
2
Input
5
1
0
150
Output
0
Input
30
40
50
6000
Output
213
### Response
```cpp
#include <iostream>
using namespace std;
int main()
{
int a,b,c;
cin>>a>>b>>c;
int zong;
cin>>zong;
int cnt=0;
for(int i=0;i<=a;i++)
for(int j=0;j<=b;j++)
for(int k=0;k<=c;k++)
if(i*500+j*100+k*50==zong)cnt++;
cout<<cnt<<endl;
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
Vasya has got a tree consisting of n vertices. He wants to delete some (possibly zero) edges in this tree such that the maximum matching in the resulting graph is unique. He asks you to calculate the number of ways to choose a set of edges to remove.
A matching in the graph is a subset of its edges such that there is no vertex incident to two (or more) edges from the subset. A maximum matching is a matching such that the number of edges in the subset is maximum possible among all matchings in this graph.
Since the answer may be large, output it modulo 998244353.
Input
The first line contains one integer n (1 β€ n β€ 3 β
10^5) β the number of vertices in the tree.
Each of the next n β 1 lines contains two integers u and v (1 β€ u, v β€ n, u β v) denoting an edge between vertex u and vertex v. It is guaranteed that these edges form a tree.
Output
Print one integer β the number of ways to delete some (possibly empty) subset of edges so that the maximum matching in the resulting graph is unique. Print the answer modulo 998244353.
Examples
Input
4
1 2
1 3
1 4
Output
4
Input
4
1 2
2 3
3 4
Output
6
Input
1
Output
1
Note
Possible ways to delete edges in the first example:
* delete (1, 2) and (1, 3).
* delete (1, 2) and (1, 4).
* delete (1, 3) and (1, 4).
* delete all edges.
Possible ways to delete edges in the second example:
* delete no edges.
* delete (1, 2) and (2, 3).
* delete (1, 2) and (3, 4).
* delete (2, 3) and (3, 4).
* delete (2, 3).
* delete all edges.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > adj(300001);
long long dp[300001][3];
void DFS(int i, int p = 0) {
dp[i][0] = 1;
dp[i][2] = 1;
long long s = 1;
for (auto j : adj[i]) {
if (j == p) {
continue;
}
DFS(j, i);
dp[i][0] = (dp[i][0] * (dp[j][0] + dp[j][1])) % 998244353;
dp[i][1] =
(dp[i][1] * (dp[j][0] + 2 * dp[j][1]) + s * dp[j][2]) % 998244353;
dp[i][2] = (dp[i][2] * (dp[j][0] + 2 * dp[j][1])) % 998244353;
s = (s * (dp[j][0] + 2 * dp[j][1])) % 998244353;
}
}
int main() {
int n;
scanf("%d", &n);
for (int x = 1; x < n; ++x) {
int i, j;
scanf("%d%d", &i, &j);
adj[i].push_back(j);
adj[j].push_back(i);
}
DFS(1);
long long ans = (dp[1][0] + dp[1][1]) % 998244353;
printf("%lld\n", ans);
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
Let's denote d(n) as the number of divisors of a positive integer n. You are given three integers a, b and c. Your task is to calculate the following sum:
<image>
Find the sum modulo 1073741824 (230).
Input
The first line contains three space-separated integers a, b and c (1 β€ a, b, c β€ 2000).
Output
Print a single integer β the required sum modulo 1073741824 (230).
Examples
Input
2 2 2
Output
20
Input
4 4 4
Output
328
Input
10 10 10
Output
11536
Note
For the first example.
* d(1Β·1Β·1) = d(1) = 1;
* d(1Β·1Β·2) = d(2) = 2;
* d(1Β·2Β·1) = d(2) = 2;
* d(1Β·2Β·2) = d(4) = 3;
* d(2Β·1Β·1) = d(2) = 2;
* d(2Β·1Β·2) = d(4) = 3;
* d(2Β·2Β·1) = d(4) = 3;
* d(2Β·2Β·2) = d(8) = 4.
So the result is 1 + 2 + 2 + 3 + 2 + 3 + 3 + 4 = 20.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int mod = 1 << 30;
vector<int> pr;
int pchk[2010];
void sieve() {
for (int i = 2; i < 2010; i++) {
if (!pchk[i]) {
pr.push_back(i);
}
for (int j = 0; j < pr.size() && i * pr[j] < 2010; j++) {
pchk[i * pr[j]] = 1;
if (i % pr[j] == 0) break;
}
}
}
int a, b, c;
unordered_map<long long, int> mm[304];
int dp(int a, int b, int c, int p) {
if (p == -1) return 1;
long long mul = (2001LL * a + b) * 2001 + c;
if (mm[p].find(mul) != mm[p].end()) return mm[p][mul];
int &ret = mm[p][mul];
ret = 0;
int q = pr[p];
for (int i = 1, x = 0; i <= a; i *= q, x++) {
for (int j = 1, y = 0; j <= b; j *= q, y++) {
for (int k = 1, z = 0; k <= c; k *= q, z++) {
ret += 1LL * (x + y + z + 1) * dp(a / i, b / j, c / k, p - 1) % mod;
ret %= mod;
}
}
}
return ret;
}
int main() {
sieve();
cin >> a >> b >> c;
cout << dp(a, b, c, pr.size() - 1);
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
You have N apples, called Apple 1, Apple 2, Apple 3, ..., Apple N. The flavor of Apple i is L+i-1, which can be negative.
You can make an apple pie using one or more of the apples. The flavor of the apple pie will be the sum of the flavors of the apples used.
You planned to make an apple pie using all of the apples, but being hungry tempts you to eat one of them, which can no longer be used to make the apple pie.
You want to make an apple pie that is as similar as possible to the one that you planned to make. Thus, you will choose the apple to eat so that the flavor of the apple pie made of the remaining N-1 apples will have the smallest possible absolute difference from the flavor of the apple pie made of all the N apples.
Find the flavor of the apple pie made of the remaining N-1 apples when you choose the apple to eat as above.
We can prove that this value is uniquely determined.
Constraints
* 2 \leq N \leq 200
* -100 \leq L \leq 100
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N L
Output
Find the flavor of the apple pie made of the remaining N-1 apples when you optimally choose the apple to eat.
Examples
Input
5 2
Output
18
Input
3 -1
Output
0
Input
30 -50
Output
-1044
### Response
```cpp
#include <iostream>
using namespace std;
int main(){
int n, l;
cin >> n >> l;
int sum = (2*l+n-1)*n/2;
if(l*(l+n-1)<=0)cout << sum;
else{
if(l<0)cout << sum-(l+n-1);
else cout << sum-l;
}
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
Over time, Alexey's mail box got littered with too many letters. Some of them are read, while others are unread.
Alexey's mail program can either show a list of all letters or show the content of a single letter. As soon as the program shows the content of an unread letter, it becomes read letter (if the program shows the content of a read letter nothing happens). In one click he can do any of the following operations:
* Move from the list of letters to the content of any single letter.
* Return to the list of letters from single letter viewing mode.
* In single letter viewing mode, move to the next or to the previous letter in the list. You cannot move from the first letter to the previous one or from the last letter to the next one.
The program cannot delete the letters from the list or rearrange them.
Alexey wants to read all the unread letters and go watch football. Now he is viewing the list of all letters and for each letter he can see if it is read or unread. What minimum number of operations does Alexey need to perform to read all unread letters?
Input
The first line contains a single integer n (1 β€ n β€ 1000) β the number of letters in the mailbox.
The second line contains n space-separated integers (zeros and ones) β the state of the letter list. The i-th number equals either 1, if the i-th number is unread, or 0, if the i-th letter is read.
Output
Print a single number β the minimum number of operations needed to make all the letters read.
Examples
Input
5
0 1 0 1 0
Output
3
Input
5
1 1 0 0 1
Output
4
Input
2
0 0
Output
0
Note
In the first sample Alexey needs three operations to cope with the task: open the second letter, move to the third one, move to the fourth one.
In the second sample the action plan: open the first letter, move to the second letter, return to the list, open the fifth letter.
In the third sample all letters are already read.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(int argc, const char* argv[]) {
int n, counts = 0;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
if (a[i] == 1 && a[i + 1] == 0 && i <= n - 2) {
counts = counts + 2;
} else if (a[i] == 1)
counts++;
}
if (a[n - 1] == 0) counts--;
if (counts < 0) counts = 0;
cout << counts;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
A triangular number is the number of dots in an equilateral triangle uniformly filled with dots. For example, three dots can be arranged in a triangle; thus three is a triangular number. The n-th triangular number is the number of dots in a triangle with n dots on a side. <image>. You can learn more about these numbers from Wikipedia (http://en.wikipedia.org/wiki/Triangular_number).
Your task is to find out if a given integer is a triangular number.
Input
The first line contains the single number n (1 β€ n β€ 500) β the given integer.
Output
If the given integer is a triangular number output YES, otherwise output NO.
Examples
Input
1
Output
YES
Input
2
Output
NO
Input
3
Output
YES
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
cin >> n;
for (int i = 1; i <= 500; ++i) {
if (i * (i + 1) == (n << 1)) {
cout << "YES";
return 0;
}
}
cout << "NO";
return 0;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
There were n groups of students which came to write a training contest. A group is either one person who can write the contest with anyone else, or two people who want to write the contest in the same team.
The coach decided to form teams of exactly three people for this training. Determine the maximum number of teams of three people he can form. It is possible that he can't use all groups to form teams. For groups of two, either both students should write the contest, or both should not. If two students from a group of two will write the contest, they should be in the same team.
Input
The first line contains single integer n (2 β€ n β€ 2Β·105) β the number of groups.
The second line contains a sequence of integers a1, a2, ..., an (1 β€ ai β€ 2), where ai is the number of people in group i.
Output
Print the maximum number of teams of three people the coach can form.
Examples
Input
4
1 1 2 1
Output
1
Input
2
2 2
Output
0
Input
7
2 2 2 1 1 1 1
Output
3
Input
3
1 1 1
Output
1
Note
In the first example the coach can form one team. For example, he can take students from the first, second and fourth groups.
In the second example he can't make a single team.
In the third example the coach can form three teams. For example, he can do this in the following way:
* The first group (of two people) and the seventh group (of one person),
* The second group (of two people) and the sixth group (of one person),
* The third group (of two people) and the fourth group (of one person).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long n, res;
long a, b;
int main() {
int x;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> x;
if (x == 1)
++a;
else
++b;
}
if (a > b)
res = b + (a - b) / 3;
else
res = a;
cout << res << endl;
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
Two bears are playing tic-tac-toe via mail. It's boring for them to play usual tic-tac-toe game, so they are a playing modified version of this game. Here are its rules.
The game is played on the following field.
<image>
Players are making moves by turns. At first move a player can put his chip in any cell of any small field. For following moves, there are some restrictions: if during last move the opposite player put his chip to cell with coordinates (xl, yl) in some small field, the next move should be done in one of the cells of the small field with coordinates (xl, yl). For example, if in the first move a player puts his chip to lower left cell of central field, then the second player on his next move should put his chip into some cell of lower left field (pay attention to the first test case). If there are no free cells in the required field, the player can put his chip to any empty cell on any field.
You are given current state of the game and coordinates of cell in which the last move was done. You should find all cells in which the current player can put his chip.
A hare works as a postman in the forest, he likes to foul bears. Sometimes he changes the game field a bit, so the current state of the game could be unreachable. However, after his changes the cell where the last move was done is not empty. You don't need to find if the state is unreachable or not, just output possible next moves according to the rules.
Input
First 11 lines contains descriptions of table with 9 rows and 9 columns which are divided into 9 small fields by spaces and empty lines. Each small field is described by 9 characters without spaces and empty lines. character "x" (ASCII-code 120) means that the cell is occupied with chip of the first player, character "o" (ASCII-code 111) denotes a field occupied with chip of the second player, character "." (ASCII-code 46) describes empty cell.
The line after the table contains two integers x and y (1 β€ x, y β€ 9). They describe coordinates of the cell in table where the last move was done. Rows in the table are numbered from up to down and columns are numbered from left to right.
It's guaranteed that cell where the last move was done is filled with "x" or "o". Also, it's guaranteed that there is at least one empty cell. It's not guaranteed that current state of game is reachable.
Output
Output the field in same format with characters "!" (ASCII-code 33) on positions where the current player can put his chip. All other cells should not be modified.
Examples
Input
... ... ...
... ... ...
... ... ...
... ... ...
... ... ...
... x.. ...
... ... ...
... ... ...
... ... ...
6 4
Output
... ... ...
... ... ...
... ... ...
... ... ...
... ... ...
... x.. ...
!!! ... ...
!!! ... ...
!!! ... ...
Input
xoo x.. x..
ooo ... ...
ooo ... ...
x.. x.. x..
... ... ...
... ... ...
x.. x.. x..
... ... ...
... ... ...
7 4
Output
xoo x!! x!!
ooo !!! !!!
ooo !!! !!!
x!! x!! x!!
!!! !!! !!!
!!! !!! !!!
x!! x!! x!!
!!! !!! !!!
!!! !!! !!!
Input
o.. ... ...
... ... ...
... ... ...
... xxx ...
... xox ...
... ooo ...
... ... ...
... ... ...
... ... ...
5 5
Output
o!! !!! !!!
!!! !!! !!!
!!! !!! !!!
!!! xxx !!!
!!! xox !!!
!!! ooo !!!
!!! !!! !!!
!!! !!! !!!
!!! !!! !!!
Note
In the first test case the first player made a move to lower left cell of central field, so the second player can put a chip only to cells of lower left field.
In the second test case the last move was done to upper left cell of lower central field, however all cells in upper left field are occupied, so the second player can put his chip to any empty cell.
In the third test case the last move was done to central cell of central field, so current player can put his chip to any cell of central field, which is already occupied, so he can move anywhere. Pay attention that this state of the game is unreachable.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void inp(T &any) {
cin >> any;
}
template <typename T, typename... U>
inline void inp(T &a, U &...b) {
cin >> a;
inp(b...);
}
template <typename T>
inline istream &operator>>(istream &in, vector<T> &a) {
for (auto &x : a) in >> x;
return in;
}
template <typename T, typename U>
inline istream &operator>>(istream &in, pair<T, U> &a) {
in >> a.first >> a.second;
return in;
}
vector<pair<long long int, long long int>> pos = {
{0, 0}, {0, 3}, {0, 6}, {3, 0}, {3, 3}, {3, 6}, {6, 0}, {6, 3}, {6, 6}};
void solve(long long int &T) {
vector<string> a(9);
for (long long int i = (0); i < (9); i++) {
string x;
for (long long int j = (0); j < (3); j++) {
std::cin >> x;
a[i] += x;
}
}
long long int x, y;
std::cin >> x >> y;
x--, y--;
long long int si = (x / 3) * 3;
long long int sj = (y / 3) * 3;
long long int nxt = 0;
for (long long int i = (si); i < (si + 3); i++) {
bool brk = false;
for (long long int j = (sj); j < (sj + 3); j++) {
if (i == x and j == y) {
brk = true;
break;
}
nxt++;
}
if (brk) break;
}
11;
si = pos[nxt].first;
sj = pos[nxt].second;
long long int add = 0;
for (long long int i = (si); i < (si + 3); i++) {
for (long long int j = (sj); j < (sj + 3); j++) {
if (a[i][j] == '.') {
add++;
a[i][j] = '!';
}
}
}
if (!add) {
for (long long int i = (0); i < (9); i++) {
for (long long int j = (0); j < (9); j++) {
if (a[i][j] == '.') {
a[i][j] = '!';
}
}
}
}
for (long long int i = (0); i < (9); i++) {
for (long long int j = (0); j < (9); j++) {
std::cout << a[i][j];
if (j % 3 == 2) {
std::cout << " ";
}
}
if (i % 3 == 2) {
cout << "\n";
}
cout << "\n";
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int t = 1;
for (long long int i = (1); i < (t + 1); i++) {
cerr << "Case #" << i << "\n";
solve(i);
}
return 0;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
Musicians of a popular band "Flayer" have announced that they are going to "make their exit" with a world tour. Of course, they will visit Berland as well.
There are n cities in Berland. People can travel between cities using two-directional train routes; there are exactly m routes, i-th route can be used to go from city vi to city ui (and from ui to vi), and it costs wi coins to use this route.
Each city will be visited by "Flayer", and the cost of the concert ticket in i-th city is ai coins.
You have friends in every city of Berland, and they, knowing about your programming skills, asked you to calculate the minimum possible number of coins they have to pay to visit the concert. For every city i you have to compute the minimum number of coins a person from city i has to spend to travel to some city j (or possibly stay in city i), attend a concert there, and return to city i (if j β i).
Formally, for every <image> you have to calculate <image>, where d(i, j) is the minimum number of coins you have to spend to travel from city i to city j. If there is no way to reach city j from city i, then we consider d(i, j) to be infinitely large.
Input
The first line contains two integers n and m (2 β€ n β€ 2Β·105, 1 β€ m β€ 2Β·105).
Then m lines follow, i-th contains three integers vi, ui and wi (1 β€ vi, ui β€ n, vi β ui, 1 β€ wi β€ 1012) denoting i-th train route. There are no multiple train routes connecting the same pair of cities, that is, for each (v, u) neither extra (v, u) nor (u, v) present in input.
The next line contains n integers a1, a2, ... ak (1 β€ ai β€ 1012) β price to attend the concert in i-th city.
Output
Print n integers. i-th of them must be equal to the minimum number of coins a person from city i has to spend to travel to some city j (or possibly stay in city i), attend a concert there, and return to city i (if j β i).
Examples
Input
4 2
1 2 4
2 3 7
6 20 1 25
Output
6 14 1 25
Input
3 3
1 2 1
2 3 1
1 3 1
30 10 20
Output
12 10 12
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pll = pair<ll, ll>;
const ll MOD = 1e9 + 7;
vector<vector<pll>> edges;
void solve() {
ll n, m;
cin >> n >> m;
edges.resize(n);
for (int i = 0, _n = (m); i < _n; i++) {
ll u, v, w;
cin >> u >> v >> w;
u--;
v--;
edges[u].push_back({v, w});
edges[v].push_back({u, w});
}
vector<long long> a(n);
for (int i = 0, _n = (n); i < _n; i++) cin >> a[i];
set<pll> second;
for (int i = 0, _n = (n); i < _n; i++) {
second.insert({a[i], i});
}
vector<bool> vis(n, 0);
while (!second.empty()) {
auto root = *(second.begin());
second.erase(second.begin());
for (auto& child : edges[root.second]) {
if (vis[child.first]) continue;
ll to = child.first;
ll wt = child.second;
if (2 * wt + root.first < a[to]) {
second.erase({a[to], to});
a[to] = 2 * wt + root.first;
second.insert({a[to], to});
}
}
vis[root.second] = 1;
}
for (auto& elem : a) {
cout << elem << ' ';
}
cout << '\n';
return;
}
int main(int argc, char** argv) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll t = 1;
while (t--) {
solve();
}
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Polycarpus is an amateur programmer. Now he is analyzing a friend's program. He has already found there the function rangeIncrement(l, r), that adds 1 to each element of some array a for all indexes in the segment [l, r]. In other words, this function does the following:
function rangeIncrement(l, r)
for i := l .. r do
a[i] = a[i] + 1
Polycarpus knows the state of the array a after a series of function calls. He wants to determine the minimum number of function calls that lead to such state. In addition, he wants to find what function calls are needed in this case. It is guaranteed that the required number of calls does not exceed 105.
Before calls of function rangeIncrement(l, r) all array elements equal zero.
Input
The first input line contains a single integer n (1 β€ n β€ 105) β the length of the array a[1... n].
The second line contains its integer space-separated elements, a[1], a[2], ..., a[n] (0 β€ a[i] β€ 105) after some series of function calls rangeIncrement(l, r).
It is guaranteed that at least one element of the array is positive. It is guaranteed that the answer contains no more than 105 calls of function rangeIncrement(l, r).
Output
Print on the first line t β the minimum number of calls of function rangeIncrement(l, r), that lead to the array from the input data. It is guaranteed that this number will turn out not more than 105.
Then print t lines β the descriptions of function calls, one per line. Each line should contain two integers li, ri (1 β€ li β€ ri β€ n) β the arguments of the i-th call rangeIncrement(l, r). Calls can be applied in any order.
If there are multiple solutions, you are allowed to print any of them.
Examples
Input
6
1 2 1 1 4 1
Output
5
2 2
5 5
5 5
5 5
1 6
Input
5
1 0 1 0 1
Output
3
1 1
3 3
5 5
Note
The first sample requires a call for the entire array, and four additional calls:
* one for the segment [2,2] (i.e. the second element of the array),
* three for the segment [5,5] (i.e. the fifth element of the array).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
struct trip {
int a, b, c;
trip(int a, int b, int c) : a(a), b(b), c(c) {}
bool operator<(const trip& o) const { return a < o.a; }
};
struct trip2 {
int a, b, c;
trip2(int a, int b, int c) : a(a), b(b), c(c) {}
bool operator<(const trip2& o) const {
if (c == o.c) {
return a < o.a;
}
return c > o.c;
}
};
set<trip> st;
set<trip2> st2;
int a[MAXN], N;
vector<pair<int, int> > ans;
int main(int argc, char* argv[]) {
scanf("%d", &N);
for (int i = 0, _i = N; i < _i; ++i) {
scanf("%d", a + i);
}
for (int i = 0; i < N;) {
int j;
for (j = i; j < N && a[i] == a[j]; j++) {
;
}
st.insert(trip(i, j - 1, a[i]));
st2.insert(trip2(i, j - 1, a[i]));
i = j;
}
while (st2.size() > 1) {
trip2 mx = *st2.begin();
st2.erase(st2.find(mx));
set<trip>::iterator mid = st.find(trip(mx.a, mx.b, mx.c));
set<trip>::iterator le = mid, ri = mid;
++ri;
int mxval = 0;
int newlo = mx.a, newhi = mx.b;
bool remr = false, reml = false;
if (ri != st.end()) {
newhi = ri->b;
mxval = ri->c;
remr = true;
}
if (le != st.begin()) {
--le;
if (mxval == le->c) {
newlo = le->a;
reml = true;
} else if (le->c > mxval) {
newhi = mx.b;
newlo = le->a;
mxval = le->c;
remr = false;
reml = true;
}
}
if (remr) {
st2.erase(st2.find(trip2(ri->a, ri->b, ri->c)));
st.erase(ri);
}
if (reml) {
st2.erase(st2.find(trip2(le->a, le->b, le->c)));
st.erase(le);
}
for (int i = 0, _i = mid->c - mxval; i < _i; ++i) {
ans.push_back(pair<int, int>(mid->a + 1, mid->b + 1));
}
st.erase(mid);
st.insert(trip(newlo, newhi, mxval));
st2.insert(trip2(newlo, newhi, mxval));
}
for (int i = 0, _i = st2.begin()->c; i < _i; ++i) {
ans.push_back(pair<int, int>(st2.begin()->a + 1, st2.begin()->b + 1));
}
printf("%d\n", ans.size());
for (int i = 0, _i = ans.size(); i < _i; ++i) {
printf("%d %d\n", ans[i].first, ans[i].second);
}
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
When the curtains are opened, a canvas unfolds outside. Kanno marvels at all the blonde colours along the riverside β not tangerines, but blossoms instead.
"What a pity it's already late spring," sighs Mino with regret, "one more drizzling night and they'd be gone."
"But these blends are at their best, aren't they?" Absorbed in the landscape, Kanno remains optimistic.
The landscape can be expressed as a row of consecutive cells, each of which either contains a flower of colour amber or buff or canary yellow, or is empty.
When a flower withers, it disappears from the cell that it originally belonged to, and it spreads petals of its colour in its two neighbouring cells (or outside the field if the cell is on the side of the landscape). In case petals fall outside the given cells, they simply become invisible.
You are to help Kanno determine whether it's possible that after some (possibly none or all) flowers shed their petals, at least one of the cells contains all three colours, considering both petals and flowers. Note that flowers can wither in arbitrary order.
Input
The first and only line of input contains a non-empty string s consisting of uppercase English letters 'A', 'B', 'C' and characters '.' (dots) only (\lvert s \rvert β€ 100) β denoting cells containing an amber flower, a buff one, a canary yellow one, and no flowers, respectively.
Output
Output "Yes" if it's possible that all three colours appear in some cell, and "No" otherwise.
You can print each letter in any case (upper or lower).
Examples
Input
.BAC.
Output
Yes
Input
AA..CB
Output
No
Note
In the first example, the buff and canary yellow flowers can leave their petals in the central cell, blending all three colours in it.
In the second example, it's impossible to satisfy the requirement because there is no way that amber and buff meet in any cell.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long inff = 0x3f3f3f3f3f3f3f3f;
string a;
int b[108][3];
map<char, int> mp;
int main() {
cin.tie(0);
cout.tie(0);
cin >> a;
int l = a.size();
int qw = 0;
mp['A'] = 0;
mp['B'] = 1;
mp['C'] = 2;
for (int i(0); i <= (l - 1); ++i) {
if (a[i] == '.') continue;
if (i == 0)
b[i + 1][mp[a[i]]] = 1;
else if (i == l - 1)
b[i - 1][mp[a[i]]] = 1;
else
b[i + 1][mp[a[i]]] = 1, b[i - 1][mp[a[i]]] = 1;
b[i][mp[a[i]]] = 1;
}
for (int i(0); i <= (l - 1); ++i) {
qw = 1;
for (int j(0); j <= (2); ++j) {
if (!b[i][j]) {
qw = 0;
break;
}
}
if (qw) {
puts("YES");
return 0;
}
}
puts("NO");
return 0;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
The only difference between easy and hard versions is constraints.
The BerTV channel every day broadcasts one episode of one of the k TV shows. You know the schedule for the next n days: a sequence of integers a_1, a_2, ..., a_n (1 β€ a_i β€ k), where a_i is the show, the episode of which will be shown in i-th day.
The subscription to the show is bought for the entire show (i.e. for all its episodes), for each show the subscription is bought separately.
How many minimum subscriptions do you need to buy in order to have the opportunity to watch episodes of purchased shows d (1 β€ d β€ n) days in a row? In other words, you want to buy the minimum number of TV shows so that there is some segment of d consecutive days in which all episodes belong to the purchased shows.
Input
The first line contains an integer t (1 β€ t β€ 100) β the number of test cases in the input. Then t test case descriptions follow.
The first line of each test case contains three integers n, k and d (1 β€ n β€ 100, 1 β€ k β€ 100, 1 β€ d β€ n). The second line contains n integers a_1, a_2, ..., a_n (1 β€ a_i β€ k), where a_i is the show that is broadcasted on the i-th day.
It is guaranteed that the sum of the values ββof n for all test cases in the input does not exceed 100.
Output
Print t integers β the answers to the test cases in the input in the order they follow. The answer to a test case is the minimum number of TV shows for which you need to purchase a subscription so that you can watch episodes of the purchased TV shows on BerTV for d consecutive days. Please note that it is permissible that you will be able to watch more than d days in a row.
Example
Input
4
5 2 2
1 2 1 2 1
9 3 3
3 3 3 2 2 2 1 1 1
4 10 4
10 8 6 4
16 9 8
3 1 4 1 5 9 2 6 5 3 5 8 9 7 9 3
Output
2
1
4
5
Note
In the first test case to have an opportunity to watch shows for two consecutive days, you need to buy a subscription on show 1 and on show 2. So the answer is two.
In the second test case, you can buy a subscription to any show because for each show you can find a segment of three consecutive days, consisting only of episodes of this show.
In the third test case in the unique segment of four days, you have four different shows, so you need to buy a subscription to all these four shows.
In the fourth test case, you can buy subscriptions to shows 3,5,7,8,9, and you will be able to watch shows for the last eight days.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int minimumSubscriptions(int n, int d, int arr[]) {
int freq[200];
memset(freq, 0, sizeof(freq));
int i;
int temp = 0;
deque<int> q;
for (i = 0; i < d; i++) {
q.push_back(arr[i]);
if (freq[arr[i]] == 0) {
temp++;
}
freq[arr[i]]++;
}
int ans = temp;
for (; i < n; i++) {
int x = q.front();
freq[x]--;
if (freq[x] == 0) {
temp--;
}
q.pop_front();
q.push_back(arr[i]);
if (freq[arr[i]] == 0) {
temp++;
}
freq[arr[i]]++;
ans = min(ans, temp);
}
return ans;
}
int main() {
int t;
cin >> t;
while (t) {
int n, k, d;
cin >> n >> k >> d;
int arr[100];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
cout << minimumSubscriptions(n, d, arr) << endl;
t--;
}
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
There are n cities in the kingdom X, numbered from 1 through n. People travel between cities by some one-way roads. As a passenger, JATC finds it weird that from any city u, he can't start a trip in it and then return back to it using the roads of the kingdom. That is, the kingdom can be viewed as an acyclic graph.
Being annoyed by the traveling system, JATC decides to meet the king and ask him to do something. In response, the king says that he will upgrade some cities to make it easier to travel. Because of the budget, the king will only upgrade those cities that are important or semi-important. A city u is called important if for every city v β u, there is either a path from u to v or a path from v to u. A city u is called semi-important if it is not important and we can destroy exactly one city v β u so that u becomes important.
The king will start to act as soon as he finds out all those cities. Please help him to speed up the process.
Input
The first line of the input contains two integers n and m (2 β€ n β€ 300 000, 1 β€ m β€ 300 000) β the number of cities and the number of one-way roads.
Next m lines describe the road system of the kingdom. Each of them contains two integers u_i and v_i (1 β€ u_i, v_i β€ n, u_i β v_i), denoting one-way road from u_i to v_i.
It is guaranteed, that the kingdoms' roads make an acyclic graph, which doesn't contain multiple edges and self-loops.
Output
Print a single integer β the number of cities that the king has to upgrade.
Examples
Input
7 7
1 2
2 3
3 4
4 7
2 5
5 4
6 4
Output
4
Input
6 7
1 2
2 3
3 4
1 5
5 3
2 6
6 4
Output
4
Note
In the first example:
<image>
* Starting at the city 1 we can reach all the other cities, except for the city 6. Also, from the city 6 we cannot reach the city 1. Therefore, if we destroy the city 6 then the city 1 will become important. So 1 is a semi-important city.
* For city 2, the set of cities that cannot reach 2 and cannot be reached by 2 is \{6\}. Therefore, destroying city 6 will make the city 2 important. So city 2 is also semi-important.
* For city 3, the set is \{5, 6\}. As you can see, destroying either city 5 or 6 will not make the city 3 important. Therefore, it is neither important nor semi-important.
* For city 4, the set is empty. So 4 is an important city.
* The set for city 5 is \{3, 6\} and the set for city 6 is \{3, 5\}. Similarly to city 3, both of them are not important nor semi-important.
* The city 7 is important since we can reach it from all other cities.
So we have two important cities (4 and 7) and two semi-important cities (1 and 2).
In the second example, the important cities are 1 and 4. The semi-important cities are 2 and 3.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<int> Go[300010];
vector<int> Gt[300010];
int in1[300010], in2[300010];
int d[300010];
int n, m, ans;
void tuopufrist() {
queue<int> Q;
int res = n;
for (int i = 1; i <= n; i++) {
if (in1[i] == 0) {
Q.push(i);
res--;
}
}
while (!Q.empty()) {
int tt = Q.front();
Q.pop();
if (Q.size() == 0) {
d[tt] += res;
}
if (Q.size() == 1) {
int flag = 1;
int ttt = Q.front();
for (int i = 0; i < Go[ttt].size(); i++) {
int ff = Go[ttt][i];
if (in1[ff] == 1) {
flag = 0;
break;
}
}
if (flag == 1) {
d[tt] += res;
}
}
for (int i = 0; i < Go[tt].size(); i++) {
int fff = Go[tt][i];
if ((--in1[fff]) == 0) {
Q.push(fff);
res--;
}
}
}
return;
}
void tuopus() {
queue<int> Q;
int res = n;
for (int i = 1; i <= n; i++) {
if (in2[i] == 0) {
Q.push(i);
res--;
}
}
while (!Q.empty()) {
int tt = Q.front();
Q.pop();
if (Q.size() == 0) {
d[tt] += res;
}
if (Q.size() == 1) {
int flag = 1;
int ttt = Q.front();
for (int i = 0; i < Gt[ttt].size(); i++) {
int ff = Gt[ttt][i];
if (in2[ff] == 1) {
flag = 0;
break;
}
}
if (flag == 1) {
d[tt] += res;
}
}
for (int i = 0; i < Gt[tt].size(); i++) {
int fff = Gt[tt][i];
if ((--in2[fff]) == 0) {
Q.push(fff);
res--;
}
}
}
return;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int mm, mmm;
scanf("%d%d", &mm, &mmm);
Go[mm].push_back(mmm);
in1[mmm]++;
Gt[mmm].push_back(mm);
in2[mm]++;
}
tuopufrist();
tuopus();
for (int i = 1; i <= n; i++) {
if (d[i] >= n - 2) {
ans++;
}
}
printf("%d\n", ans);
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
Write a program which finds a pattern $p$ in a ring shaped text $s$.
<image>
Constraints
* $1 \leq $ length of $p \leq $ length of $s \leq 100$
* $s$ and $p$ consists of lower-case letters
Input
In the first line, the text $s$ is given.
In the second line, the pattern $p$ is given.
Output
If $p$ is in $s$, print Yes in a line, otherwise No.
Examples
Input
vanceknowledgetoad
advance
Output
Yes
Input
vanceknowledgetoad
advanced
Output
No
### Response
```cpp
#include <iostream>
#include <string>
int main()
{
std::string s, p;
std::cin >> s >> p;
s += s;
if (s.find(p) != std::string::npos)
std::cout << "Yes\n";
else
std::cout << "No\n";
return 0;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
The Little Elephant has an integer a, written in the binary notation. He wants to write this number on a piece of paper.
To make sure that the number a fits on the piece of paper, the Little Elephant ought to delete exactly one any digit from number a in the binary record. At that a new number appears. It consists of the remaining binary digits, written in the corresponding order (possible, with leading zeroes).
The Little Elephant wants the number he is going to write on the paper to be as large as possible. Help him find the maximum number that he can obtain after deleting exactly one binary digit and print it in the binary notation.
Input
The single line contains integer a, written in the binary notation without leading zeroes. This number contains more than 1 and at most 105 digits.
Output
In the single line print the number that is written without leading zeroes in the binary notation β the answer to the problem.
Examples
Input
101
Output
11
Input
110010
Output
11010
Note
In the first sample the best strategy is to delete the second digit. That results in number 112 = 310.
In the second sample the best strategy is to delete the third or fourth digits β that results in number 110102 = 2610.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string st, s;
cin >> st;
long long f = 0, sz = st.size();
for (long long i = 0; i < sz; i++) {
if (st[i] == '0' && f == 0)
f = 1;
else
s += st[i];
}
if (f)
cout << s << endl;
else {
for (long long i = 0; i < sz - 1; i++) cout << st[i];
}
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
You are given a bracket sequence s of length n, where n is even (divisible by two). The string s consists of n/2 opening brackets '(' and n/2 closing brackets ')'.
In one move, you can choose exactly one bracket and move it to the beginning of the string or to the end of the string (i.e. you choose some index i, remove the i-th character of s and insert it before or after all remaining characters of s).
Your task is to find the minimum number of moves required to obtain regular bracket sequence from s. It can be proved that the answer always exists under the given constraints.
Recall what the regular bracket sequence is:
* "()" is regular bracket sequence;
* if s is regular bracket sequence then "(" + s + ")" is regular bracket sequence;
* if s and t are regular bracket sequences then s + t is regular bracket sequence.
For example, "()()", "(())()", "(())" and "()" are regular bracket sequences, but ")(", "()(" and ")))" are not.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 2000) β the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (2 β€ n β€ 50) β the length of s. It is guaranteed that n is even. The second line of the test case containg the string s consisting of n/2 opening and n/2 closing brackets.
Output
For each test case, print the answer β the minimum number of moves required to obtain regular bracket sequence from s. It can be proved that the answer always exists under the given constraints.
Example
Input
4
2
)(
4
()()
8
())()()(
10
)))((((())
Output
1
0
1
3
Note
In the first test case of the example, it is sufficient to move the first bracket to the end of the string.
In the third test case of the example, it is sufficient to move the last bracket to the beginning of the string.
In the fourth test case of the example, we can choose last three openning brackets, move them to the beginning of the string and obtain "((()))(())".
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
while (n--) {
int x;
cin >> x;
stack<char> k;
string s;
cin >> s;
int op = 0;
for (int i = 0; i < x; i++) {
if (s[i] == '(') {
k.push(s[i]);
op++;
} else {
if (!k.empty()) {
k.pop();
op++;
}
}
}
cout << x - op << endl;
}
return 0;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
The biggest gold mine in Berland consists of n caves, connected by n - 1 transitions. The entrance to the mine leads to the cave number 1, it is possible to go from it to any remaining cave of the mine by moving along the transitions.
The mine is being developed by the InMine Inc., k miners work for it. Each day the corporation sorts miners into caves so that each cave has at most one miner working there.
For each cave we know the height of its ceiling hi in meters, and for each miner we know his height sj, also in meters. If a miner's height doesn't exceed the height of the cave ceiling where he is, then he can stand there comfortably, otherwise, he has to stoop and that makes him unhappy.
Unfortunately, miners typically go on strike in Berland, so InMine makes all the possible effort to make miners happy about their work conditions. To ensure that no miner goes on strike, you need make sure that no miner has to stoop at any moment on his way from the entrance to the mine to his cave (in particular, he must be able to stand comfortably in the cave where he works).
To reach this goal, you can choose exactly one cave and increase the height of its ceiling by several meters. However enlarging a cave is an expensive and complex procedure. That's why InMine Inc. asks you either to determine the minimum number of meters you should raise the ceiling of some cave so that it is be possible to sort the miners into the caves and keep all miners happy with their working conditions or to determine that it is impossible to achieve by raising ceiling in exactly one cave.
Input
The first line contains integer n (1 β€ n β€ 5Β·105) β the number of caves in the mine.
Then follows a line consisting of n positive integers h1, h2, ..., hn (1 β€ hi β€ 109), where hi is the height of the ceiling in the i-th cave.
Next n - 1 lines contain the descriptions of transitions between the caves. Each line has the form ai, bi (1 β€ ai, bi β€ n, ai β bi), where ai and bi are the numbers of the caves connected by a path.
The next line contains integer k (1 β€ k β€ n).
The last line contains k integers s1, s2, ..., sk (1 β€ sj β€ 109), where sj is the j-th miner's height.
Output
In the single line print the minimum number of meters that you need to raise the ceiling by in some cave so that all miners could be sorted into caves and be happy about the work conditions. If it is impossible to do, print - 1. If it is initially possible and there's no need to raise any ceiling, print 0.
Examples
Input
6
5 8 4 6 3 12
1 2
1 3
4 2
2 5
6 3
6
7 4 2 5 3 11
Output
6
Input
7
10 14 7 12 4 50 1
1 2
2 3
2 4
5 1
6 5
1 7
6
7 3 4 8 8 10
Output
0
Input
3
4 2 8
1 2
1 3
2
17 15
Output
-1
Note
In the first sample test we should increase ceiling height in the first cave from 5 to 11. After that we can distribute miners as following (first goes index of a miner, then index of a cave): <image>.
In the second sample test there is no need to do anything since it is already possible to distribute miners as following: <image>.
In the third sample test it is impossible.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <typename A>
ostream& operator<<(ostream& cout, vector<A> const& v);
template <typename A, typename B>
ostream& operator<<(ostream& cout, pair<A, B> const& p) {
return cout << "(" << p.first << ", " << p.second << ")";
}
template <typename A>
ostream& operator<<(ostream& cout, vector<A> const& v) {
cout << "[";
for (int i = 0; i < v.size(); i++) {
if (i) cout << ", ";
cout << v[i];
}
return cout << "]";
}
template <typename A, typename B>
istream& operator>>(istream& cin, pair<A, B>& p) {
cin >> p.first;
return cin >> p.second;
}
mt19937_64 rng(std::chrono::steady_clock::now().time_since_epoch().count());
void usaco(string filename) {
freopen((filename + ".in").c_str(), "r", stdin);
freopen((filename + ".out").c_str(), "w", stdout);
}
const long double pi = 3.14159265358979323846;
struct segtree {
int n, depth;
vector<long long> tree, lazy;
void init(int second, long long* arr) {
n = second;
tree = vector<long long>(4 * second, 0);
lazy = vector<long long>(4 * second, 0);
init(0, 0, n - 1, arr);
}
long long init(int i, int l, int r, long long* arr) {
if (l == r) return tree[i] = arr[l];
int mid = (l + r) / 2;
long long a = init(2 * i + 1, l, mid, arr),
b = init(2 * i + 2, mid + 1, r, arr);
return tree[i] = a > b ? a : b;
}
void update(int l, int r, long long v) { update(0, 0, n - 1, l, r, v); }
long long update(int i, int tl, int tr, int ql, int qr, long long v) {
eval_lazy(i, tl, tr);
if (tr < ql || qr < tl) return tree[i];
if (ql <= tl && tr <= qr) {
lazy[i] += v;
eval_lazy(i, tl, tr);
return tree[i];
}
int mid = (tl + tr) / 2;
long long a = update(2 * i + 1, tl, mid, ql, qr, v),
b = update(2 * i + 2, mid + 1, tr, ql, qr, v);
return tree[i] = a > b ? a : b;
}
long long query(int l, int r) { return query(0, 0, n - 1, l, r); }
long long query(int i, int tl, int tr, int ql, int qr) {
eval_lazy(i, tl, tr);
if (ql <= tl && tr <= qr) return tree[i];
if (tr < ql || qr < tl) return 1e13;
int mid = (tl + tr) / 2;
long long a = query(2 * i + 1, tl, mid, ql, qr),
b = query(2 * i + 2, mid + 1, tr, ql, qr);
return a > b ? a : b;
}
void eval_lazy(int i, int l, int r) {
tree[i] += lazy[i];
if (l != r) {
lazy[i * 2 + 1] += lazy[i];
lazy[i * 2 + 2] += lazy[i];
}
lazy[i] = 0;
}
};
long long n, m, q, k, l, r, x, y, z;
const long long template_array_size = 1e6 + 16318;
long long a[template_array_size];
long long b[template_array_size];
long long c[template_array_size];
string second, t;
long long ans = 0;
vector<long long> edges[500005];
vector<long long> ch[500005];
long long val[500005];
long long val2[500005];
long long vl[500005];
long long dep[500005];
bool can[500005];
segtree st;
bool cval(long long a, long long b) {
if (val[a] == val[b]) return dep[a] < dep[b];
return val[a] > val[b];
}
void setv(long long v, long long p, long long va, long long d = 0) {
val[v] = va;
dep[v] = d;
for (long long x : edges[v]) {
if (x != p) {
ch[v].push_back(x);
setv(x, v, min(va, a[x]), d + 1);
}
}
}
void add(long long val, long long x) {
long long lv = 0, rv = k;
while (lv < rv) {
long long mv = (lv + rv) / 2;
if (b[mv] > val)
lv = mv + 1;
else
rv = mv;
}
if (lv < k) st.update(lv, k - 1, x);
}
vector<long long> cur;
long long tsz = 0;
void checkv(long long v, long long va) {
val2[v] = va;
cur.push_back(v);
for (long long x : ch[v]) {
checkv(x, min(va, a[x]));
}
}
bool check(long long v, long long t) {
cur.clear();
checkv(v, t);
tsz += cur.size();
for (long long x : cur) {
add(val[x], 1);
add(val2[x], -1);
}
bool pos = (st.query(0, k - 1) <= 0);
for (long long x : cur) {
add(val2[x], 1);
add(val[x], -1);
}
return pos;
}
void solve(int tc = 0) {
cin >> n;
for (long long i = 0; i < n; i++) cin >> a[i];
for (long long i = 0; i < n - 1; i++) {
cin >> x >> y;
--x;
--y;
edges[x].push_back(y);
edges[y].push_back(x);
}
setv(0, -1, a[0]);
cin >> k;
for (long long i = 0; i < k; i++) cin >> b[i];
sort(b, b + k);
reverse(b, b + k);
iota(c, c + k, 1);
st.init(k, c);
for (long long i = 0; i < n; i++) add(val[i], -1);
iota(vl, vl + n, 0);
sort(vl, vl + n, cval);
long long sent = 1e17;
long long ans = sent;
can[0] = 1;
bool pos = 1;
for (long long i = 0; i < k; i++) {
long long x = vl[i];
if (val[x] >= b[i]) {
for (long long y : ch[x]) can[y] = 1;
can[x] = 0;
} else {
pos = 0;
for (long long j = 0; j < n; j++) {
if (can[j]) {
if (check(j, b[i])) {
ans = min(ans, b[i] - val[j]);
}
}
}
break;
}
}
if (pos) ans = 0;
if (ans == sent) ans = -1;
cout << ans << '\n';
}
int main() {
{ ios_base::sync_with_stdio(false); }
{ cin.tie(NULL); }
cout << setprecision(15) << fixed;
int tc = 1;
for (int t = 0; t < tc; t++) solve(t);
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
<image>
Input
The input contains a single floating-point number x with exactly 6 decimal places (0 < x < 5).
Output
Output two integers separated by a single space. Each integer should be between 1 and 10, inclusive. If several solutions exist, output any of them. Solution will exist for all tests.
Examples
Input
1.200000
Output
3 2
Input
2.572479
Output
10 3
Input
4.024922
Output
9 9
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
double const pi = acos(-1.0);
int main() {
double x;
cin >> x;
for (int i = 1; i <= 10; ++i) {
for (int j = 1; j <= 10; ++j) {
double a = i * 1.0, h = j * 1.0;
double c = sqrt(0.5 * a * 0.5 * a + h * h);
double r = 0.5 * h * a / c;
if (fabs(x - r) < 1e-6) {
cout << i << " " << j << endl;
return 0;
}
}
}
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
Iahub likes chess very much. He even invented a new chess piece named Coder. A Coder can move (and attack) one square horizontally or vertically. More precisely, if the Coder is located at position (x, y), he can move to (or attack) positions (x + 1, y), (xβ1, y), (x, y + 1) and (x, yβ1).
Iahub wants to know how many Coders can be placed on an n Γ n chessboard, so that no Coder attacks any other Coder.
Input
The first line contains an integer n (1 β€ n β€ 1000).
Output
On the first line print an integer, the maximum number of Coders that can be placed on the chessboard.
On each of the next n lines print n characters, describing the configuration of the Coders. For an empty cell print an '.', and for a Coder print a 'C'.
If there are multiple correct answers, you can print any.
Examples
Input
2
Output
2
C.
.C
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
cout << n * n / 2 + (n * n) % 2 << endl;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i % 2 == 0) {
if (j % 2 == 0) {
cout << 'C';
} else {
cout << '.';
}
} else {
if (j % 2 == 0) {
cout << '.';
} else {
cout << 'C';
}
}
}
cout << '\n';
}
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
Everybody knows of [spaghetti sort](https://en.wikipedia.org/wiki/Spaghetti_sort). You decided to implement an analog sorting algorithm yourself, but as you survey your pantry you realize you're out of spaghetti! The only type of pasta you have is ravioli, but you are not going to let this stop you...
You come up with the following algorithm. For each number in the array ai, build a stack of ai ravioli. The image shows the stack for ai = 4.
<image>
Arrange the stacks in one row in the order in which the corresponding numbers appear in the input array. Find the tallest one (if there are several stacks of maximal height, use the leftmost one). Remove it and add its height to the end of the output array. Shift the stacks in the row so that there is no gap between them. Repeat the procedure until all stacks have been removed.
At first you are very happy with your algorithm, but as you try it on more inputs you realize that it doesn't always produce the right sorted array. Turns out when two stacks of ravioli are next to each other (at any step of the process) and differ in height by two or more, the top ravioli of the taller stack slides down on top of the lower stack.
Given an input array, figure out whether the described algorithm will sort it correctly.
Input
The first line of input contains a single number n (1 β€ n β€ 10) β the size of the array.
The second line of input contains n space-separated integers ai (1 β€ ai β€ 100) β the elements of the array.
Output
Output "YES" if the array can be sorted using the described procedure and "NO" if it can not.
Examples
Input
3
1 2 3
Output
YES
Input
3
3 1 2
Output
NO
Note
In the second example the array will change even before the tallest stack is chosen for the first time: ravioli from stack of height 3 will slide on the stack of height 1, and the algorithm will output an array {2, 2, 2}.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int err = 0;
int t;
scanf("%d", &t);
int y;
t--;
vector<int> st;
priority_queue<int> pq;
scanf("%d", &y);
st.push_back(y);
pq.push(y);
while (t--) {
int x;
scanf("%d", &x);
st.push_back(x);
pq.push(x);
if (abs(x - y) >= 2) err = 1;
y = x;
}
if (err) {
puts("NO");
return 0;
}
while (!err && st.size() > 2) {
int idx;
for (int i = 0; i < st.size(); i++) {
if (st[i] == pq.top()) {
if (i - 1 >= 0 && i + 1 < st.size()) {
if (abs(st[i - 1] - st[i + 1]) >= 2) err = 1;
}
st.erase(st.begin() + i);
break;
}
}
pq.pop();
}
if (err)
puts("NO");
else
puts("YES");
return 0;
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
Polar bears Menshykov and Uslada from the zoo of St. Petersburg and elephant Horace from the zoo of Kiev decided to build a house of cards. For that they've already found a hefty deck of n playing cards. Let's describe the house they want to make:
1. The house consists of some non-zero number of floors.
2. Each floor consists of a non-zero number of rooms and the ceiling. A room is two cards that are leaned towards each other. The rooms are made in a row, each two adjoining rooms share a ceiling made by another card.
3. Each floor besides for the lowest one should contain less rooms than the floor below.
Please note that the house may end by the floor with more than one room, and in this case they also must be covered by the ceiling. Also, the number of rooms on the adjoining floors doesn't have to differ by one, the difference may be more.
While bears are practicing to put cards, Horace tries to figure out how many floors their house should consist of. The height of the house is the number of floors in it. It is possible that you can make a lot of different houses of different heights out of n cards. It seems that the elephant cannot solve this problem and he asks you to count the number of the distinct heights of the houses that they can make using exactly n cards.
Input
The single line contains integer n (1 β€ n β€ 1012) β the number of cards.
Output
Print the number of distinct heights that the houses made of exactly n cards can have.
Examples
Input
13
Output
1
Input
6
Output
0
Note
In the first sample you can build only these two houses (remember, you must use all the cards):
<image>
Thus, 13 cards are enough only for two floor houses, so the answer is 1.
The six cards in the second sample are not enough to build any house.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 5;
long long n, ans = 0, t, a[maxn];
int main() {
for (long long i = 1; i < maxn; i++) {
a[i] = (i * i * 3LL + i) / 2LL;
}
scanf("%I64d", &n);
long long cnt = 0, m = n;
while (m > 0) {
m -= 2;
cnt++;
if (m % 3 == 0) break;
}
if (cnt == 1 && n < 2)
printf("0\n");
else if (cnt == 2 && n < 7) {
printf("0\n");
} else if (cnt == 3 && n < 15)
printf("0\n");
else {
for (int i = cnt;; i += 3) {
if (a[i] > n) {
break;
}
ans++;
}
printf("%I64d\n", ans);
}
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
There are N students and M checkpoints on the xy-plane.
The coordinates of the i-th student (1 \leq i \leq N) is (a_i,b_i), and the coordinates of the checkpoint numbered j (1 \leq j \leq M) is (c_j,d_j).
When the teacher gives a signal, each student has to go to the nearest checkpoint measured in Manhattan distance.
The Manhattan distance between two points (x_1,y_1) and (x_2,y_2) is |x_1-x_2|+|y_1-y_2|.
Here, |x| denotes the absolute value of x.
If there are multiple nearest checkpoints for a student, he/she will select the checkpoint with the smallest index.
Which checkpoint will each student go to?
Constraints
* 1 \leq N,M \leq 50
* -10^8 \leq a_i,b_i,c_j,d_j \leq 10^8
* All input values are integers.
Input
The input is given from Standard Input in the following format:
N M
a_1 b_1
:
a_N b_N
c_1 d_1
:
c_M d_M
Output
Print N lines.
The i-th line (1 \leq i \leq N) should contain the index of the checkpoint for the i-th student to go.
Examples
Input
2 2
2 0
0 0
-1 0
1 0
Output
2
1
Input
3 4
10 10
-10 -10
3 3
1 2
2 3
3 5
3 5
Output
3
1
2
Input
5 5
-100000000 -100000000
-100000000 100000000
100000000 -100000000
100000000 100000000
0 0
0 0
100000000 100000000
100000000 -100000000
-100000000 100000000
-100000000 -100000000
Output
5
4
3
2
1
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,m;
cin>>n>>m;
long long a[55],b[55],c,d,e[55],mn[55];
for(int i=0;i<n;i++){
cin>>a[i]>>b[i];
mn[i]=1000000000;
}
for(int i=0;i<m;i++){
cin>>c>>d;
for(int j=0;j<n;j++){
if(mn[j]>abs(a[j]-c)+abs(b[j]-d)){
mn[j]=abs(a[j]-c)+abs(b[j]-d);
e[j]=i+1;
}
}
}
for(int i=0;i<n;i++){
cout<<e[i]<<endl;
}
return 0;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
Have you ever played Hanabi? If not, then you've got to try it out! This problem deals with a simplified version of the game.
Overall, the game has 25 types of cards (5 distinct colors and 5 distinct values). Borya is holding n cards. The game is somewhat complicated by the fact that everybody sees Borya's cards except for Borya himself. Borya knows which cards he has but he knows nothing about the order they lie in. Note that Borya can have multiple identical cards (and for each of the 25 types of cards he knows exactly how many cards of this type he has).
The aim of the other players is to achieve the state when Borya knows the color and number value of each of his cards. For that, other players can give him hints. The hints can be of two types: color hints and value hints.
A color hint goes like that: a player names some color and points at all the cards of this color.
Similarly goes the value hint. A player names some value and points at all the cards that contain the value.
Determine what minimum number of hints the other players should make for Borya to be certain about each card's color and value.
Input
The first line contains integer n (1 β€ n β€ 100) β the number of Borya's cards. The next line contains the descriptions of n cards. The description of each card consists of exactly two characters. The first character shows the color (overall this position can contain five distinct letters β R, G, B, Y, W). The second character shows the card's value (a digit from 1 to 5). Borya doesn't know exact order of the cards they lie in.
Output
Print a single integer β the minimum number of hints that the other players should make.
Examples
Input
2
G3 G3
Output
0
Input
4
G4 R4 R3 B3
Output
2
Input
5
B1 Y1 W1 G1 R1
Output
4
Note
In the first sample Borya already knows for each card that it is a green three.
In the second sample we can show all fours and all red cards.
In the third sample you need to make hints about any four colors.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100 + 5;
int count(int x) {
int res = 0;
while (x) {
res += x % 2;
x /= 2;
}
return res;
}
int a[maxn], b[maxn], c[maxn];
int main(void) {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
char s[5];
scanf("%s", s);
if (s[0] == 'R') {
a[i] = 0;
} else if (s[0] == 'G') {
a[i] = 1;
} else if (s[0] == 'B') {
a[i] = 2;
} else if (s[0] == 'Y') {
a[i] = 3;
} else {
a[i] = 4;
}
b[i] = s[1] - '1';
}
int res = 10;
for (int i = 0; i < (1 << 10); i++) {
bool flag = true;
memset(c, 0, sizeof(c));
for (int j = 1; j <= n; j++) {
if ((i >> (a[j] + 5)) & 1) {
c[j] |= 1 << (a[j] + 5);
}
if ((i >> b[j]) & 1) {
c[j] |= 1 << b[j];
}
for (int k = 1; k < j; k++) {
if (c[j] == c[k] && (a[j] != a[k] || b[j] != b[k])) {
flag = false;
break;
}
}
if (!flag) {
break;
}
}
if (flag) {
res = min(res, count(i));
}
}
printf("%d\n", res);
return 0;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
You've got a 5 Γ 5 matrix, consisting of 24 zeroes and a single number one. Let's index the matrix rows by numbers from 1 to 5 from top to bottom, let's index the matrix columns by numbers from 1 to 5 from left to right. In one move, you are allowed to apply one of the two following transformations to the matrix:
1. Swap two neighboring matrix rows, that is, rows with indexes i and i + 1 for some integer i (1 β€ i < 5).
2. Swap two neighboring matrix columns, that is, columns with indexes j and j + 1 for some integer j (1 β€ j < 5).
You think that a matrix looks beautiful, if the single number one of the matrix is located in its middle (in the cell that is on the intersection of the third row and the third column). Count the minimum number of moves needed to make the matrix beautiful.
Input
The input consists of five lines, each line contains five integers: the j-th integer in the i-th line of the input represents the element of the matrix that is located on the intersection of the i-th row and the j-th column. It is guaranteed that the matrix consists of 24 zeroes and a single number one.
Output
Print a single integer β the minimum number of moves needed to make the matrix beautiful.
Examples
Input
0 0 0 0 0
0 0 0 0 1
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
Output
3
Input
0 0 0 0 0
0 0 0 0 0
0 1 0 0 0
0 0 0 0 0
0 0 0 0 0
Output
1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int k, n;
for (int i = 1; i <= 25; i++) {
cin >> k;
if (k == 1) {
n = i;
}
}
if (n == 1 || n == 5 || n == 21 || n == 25) {
cout << 4;
} else if (n == 8 || n == 18 || n == 12 || n == 14) {
cout << 1;
} else if (n == 13) {
cout << 0;
} else if (n == 7 || n == 9 || n == 17 || n == 19 || n == 3 || n == 11 ||
n == 15 || n == 23) {
cout << 2;
} else {
cout << 3;
}
}
``` |
### Prompt
Generate a cpp solution to the following problem:
Consider a circle whose perimeter is divided by N points into N arcs of equal length, and each of the arcs is painted red or blue. Such a circle is said to generate a string S from every point when the following condition is satisfied:
* We will arbitrarily choose one of the N points on the perimeter and place a piece on it.
* Then, we will perform the following move M times: move the piece clockwise or counter-clockwise to an adjacent point.
* Here, whatever point we choose initially, it is always possible to move the piece so that the color of the i-th arc the piece goes along is S_i, by properly deciding the directions of the moves.
Assume that, if S_i is `R`, it represents red; if S_i is `B`, it represents blue. Note that the directions of the moves can be decided separately for each choice of the initial point.
You are given a string S of length M consisting of `R` and `B`. Out of the 2^N ways to paint each of the arcs red or blue in a circle whose perimeter is divided into N arcs of equal length, find the number of ways resulting in a circle that generates S from every point, modulo 10^9+7.
Note that the rotations of the same coloring are also distinguished.
Constraints
* 2 \leq N \leq 2 \times 10^5
* 1 \leq M \leq 2 \times 10^5
* |S|=M
* S_i is `R` or `B`.
Input
Input is given from Standard Input in the following format:
N M
S
Output
Print the number of ways to paint each of the arcs that satisfy the condition, modulo 10^9+7.
Examples
Input
4 7
RBRRBRR
Output
2
Input
3 3
BBB
Output
4
Input
12 10
RRRRBRRRRB
Output
78
### Response
```cpp
#include <bits/stdc++.h>
#define pb push_back
#define F first
#define S second
#define all(x) x.begin(), x.end()
#define debug(x)// cerr << #x << " = " << x << endl
using namespace std;
typedef long long ll;
typedef long double ld;
typedef string str;
typedef pair<ll, ll> pll;
const ld PI = 3.14159265359;
const ll MOD = (ll) 1e9 + 7;
const ll MAXN = (ll) 3e5 + 10;
const ll INF = (ll) 2242545357980376863;
const ld EPS = (ld) 1e-8;
vector<ll> A;
ll dp[MAXN], sm[MAXN];
int main(){
ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
ll n, m;
cin >> n >> m;
str s;
cin >> s;
ll cnt = 1;
for(int i = 1; i < m; i++){
if(s[i] == s[i - 1]) cnt ++;
else {
A.pb(cnt);
cnt = 1;
}
}
A.pb(cnt);
if(A.size() == 1){
//debug("S");
dp[1] = 1;
dp[2] = 0;
sm[1] = 1;
sm[2] = 1;
for(int i = 3; i <= n; i++){
dp[i] = sm[i - 2];
sm[i] = (dp[i] + sm[i - 1]) % MOD;
}
ll ans = 1;
for(int len = 1; len <= n - 1; len ++){
ans += (len + 1ll) * dp[n - len];
ans %= MOD;
}
cout << ans;
return 0;
/////
}
ll mx;
if(A[0] % 2 == 0) mx = A[0] + 1;
else mx = A[0];
for(int i = 2; i + 1 < A.size(); i += 2){
if(A[i] % 2 == 1) mx = min(mx, A[i]);
}
debug(mx);
dp[0] = 0;
dp[1] = 1;
dp[3] = 1;
for(int i = 5; i <= n; i++){
dp[i] = dp[i - 2] + dp[i - 2];
if(i >= mx + 3) dp[i] -= dp[i - mx - 3];
dp[i] %= MOD;
}
//debug(dp[1]);
//debug(dp[3]);
ll ans = 0;
for(ll len = 1; len <= min(n-1ll, mx); len += 2){
ans += ((len + 1ll) * dp[n - len]);
ans %= MOD;
}
cout << ((ans % MOD) + MOD)%MOD;
return 0;
}
/*
____ ,----.. ,----..
,---, ,' , `. / / \ / / \
' .' \ ,-+-,.' _ | / . : / . :
/ ; '. ,-+-. ; , || . / ;. \ . / ;. \
: : \ ,--.'|' | ;| . ; / ` ; . ; / ` ;
: | /\ \ | | ,', | ': ; | ; \ ; | ; | ; \ ; |
| : ' ;. : | | / | | || | : | ; | ' | : | ; | '
| | ;/ \ \ ' | : | : |, . | ' ' ' : . | ' ' ' :
' : | \ \ ,' ; . | ; |--' ' ; \; / | ' ; \; / |
| | ' '--' | : | | , \ \ ', / \ \ ', /
| : : | : ' |/ ; : / ; : /
| | ,' ; | |`-' \ \ .' \ \ .'
`--'' | ;/ `---` `---`
'---'
*/
``` |
### Prompt
Generate a Cpp solution to the following problem:
Thumbelina has had an accident. She has found herself on a little island in the middle of a swamp and wants to get to the shore very much.
One can get to the shore only by hills that are situated along a straight line that connects the little island with the shore. Let us assume that the hills are numbered from 1 to n and the number of a hill is equal to the distance in meters between it and the island. The distance between the n-th hill and the shore is also 1 meter.
Thumbelina is too small to make such jumps. Fortunately, a family of frogs living in the swamp suggests to help her. Each frog agrees to give Thumbelina a ride but Thumbelina should choose only one frog. Each frog has a certain jump length. If Thumbelina agrees to accept help from a frog whose jump length is d, the frog will jump from the island on the hill d, then β on the hill 2d, then 3d and so on until they get to the shore (i.e. find itself beyond the hill n).
However, there is one more problem: mosquitoes also live in the swamp. At the moment they have a siesta, and they are having a nap on some hills. If the frog jumps on a hill with a mosquito the frog will smash it. The frogs Thumbelina has met are pacifists, so they will find the death of each mosquito very much sad. Help Thumbelina choose a frog that will bring her to the shore and smash as small number of mosquitoes as possible.
Input
The first line contains three integers n, m and k (1 β€ n β€ 109, 1 β€ m, k β€ 100) β the number of hills, frogs and mosquitoes respectively. The second line contains m integers di (1 β€ di β€ 109) β the lengths of the frogsβ jumps. The third line contains k integers β the numbers of the hills on which each mosquito is sleeping. No more than one mosquito can sleep on each hill. The numbers in the lines are separated by single spaces.
Output
In the first line output the number of frogs that smash the minimal number of mosquitoes, in the second line β their numbers in increasing order separated by spaces. The frogs are numbered from 1 to m in the order of the jump length given in the input data.
Examples
Input
5 3 5
2 3 4
1 2 3 4 5
Output
2
2 3
Input
1000000000 2 3
2 5
999999995 999999998 999999996
Output
1
2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
pair<int, int> d[100007];
int ma[100007], a[100007];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m, k;
cin >> n >> m >> k;
for (int i = 0; i < (m); i++) cin >> d[i].first, d[i].second = i;
for (int i = 0; i < (k); i++) cin >> ma[i];
sort(d, d + m);
for (int i = m - 1; i >= 0; i--) {
for (int j = 0; j < (k); j++)
if (!(ma[j] % d[i].first)) {
a[d[i].second]++;
}
}
int mn = *min_element(a, a + m);
vector<int> v;
for (int i = 0; i < (m); i++) {
if (a[i] == mn) v.push_back(i);
}
cout << ((int)v.size()) << endl;
for (int i = 0; i < (((int)v.size())); i++) cout << v[i] + 1 << ' ';
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
The mobile application store has a new game called "Subway Roller".
The protagonist of the game Philip is located in one end of the tunnel and wants to get out of the other one. The tunnel is a rectangular field consisting of three rows and n columns. At the beginning of the game the hero is in some cell of the leftmost column. Some number of trains rides towards the hero. Each train consists of two or more neighbouring cells in some row of the field.
All trains are moving from right to left at a speed of two cells per second, and the hero runs from left to right at the speed of one cell per second. For simplicity, the game is implemented so that the hero and the trains move in turns. First, the hero moves one cell to the right, then one square up or down, or stays idle. Then all the trains move twice simultaneously one cell to the left. Thus, in one move, Philip definitely makes a move to the right and can move up or down. If at any point, Philip is in the same cell with a train, he loses. If the train reaches the left column, it continues to move as before, leaving the tunnel.
Your task is to answer the question whether there is a sequence of movements of Philip, such that he would be able to get to the rightmost column.
<image>
Input
Each test contains from one to ten sets of the input data. The first line of the test contains a single integer t (1 β€ t β€ 10 for pretests and tests or t = 1 for hacks; see the Notes section for details) β the number of sets.
Then follows the description of t sets of the input data.
The first line of the description of each set contains two integers n, k (2 β€ n β€ 100, 1 β€ k β€ 26) β the number of columns on the field and the number of trains. Each of the following three lines contains the sequence of n character, representing the row of the field where the game is on. Philip's initial position is marked as 's', he is in the leftmost column. Each of the k trains is marked by some sequence of identical uppercase letters of the English alphabet, located in one line. Distinct trains are represented by distinct letters. Character '.' represents an empty cell, that is, the cell that doesn't contain either Philip or the trains.
Output
For each set of the input data print on a single line word YES, if it is possible to win the game and word NO otherwise.
Examples
Input
2
16 4
...AAAAA........
s.BBB......CCCCC
........DDDDD...
16 4
...AAAAA........
s.BBB....CCCCC..
.......DDDDD....
Output
YES
NO
Input
2
10 4
s.ZZ......
.....AAABB
.YYYYYY...
10 4
s.ZZ......
....AAAABB
.YYYYYY...
Output
YES
NO
Note
In the first set of the input of the first sample Philip must first go forward and go down to the third row of the field, then go only forward, then go forward and climb to the second row, go forward again and go up to the first row. After that way no train blocks Philip's path, so he can go straight to the end of the tunnel.
Note that in this problem the challenges are restricted to tests that contain only one testset.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int dx[3] = {-1, 1, 0};
int dy[3] = {1, 1, 1};
int d[5][205];
char mp[5][205];
int n, k, flag;
int bfs(int sx, int sy) {
queue<pair<int, int> > que;
memset(d, 0, sizeof(d));
while (!que.empty()) que.pop();
que.push(pair<int, int>(sx, sy));
d[sx][sy] = 1;
while (que.size()) {
pair<int, int> tmp = que.front();
que.pop();
if (tmp.second >= n) {
return 1;
}
if (mp[tmp.first][tmp.second + 1] != '.') continue;
if (tmp.first < 0 || tmp.first > 2) continue;
for (int i = 0; i < 3; i++) {
int nx = tmp.first + dx[i];
int ny = tmp.second + dy[i];
if (mp[nx][ny] == '.' && mp[nx][ny + 1] == '.' && mp[nx][ny + 2] == '.') {
if (d[nx][ny + 2] == 0) {
d[nx][ny + 2] = 1;
que.push(pair<int, int>(nx, ny + 2));
}
}
}
}
return 0;
}
int main() {
int t;
cin >> t;
while (t--) {
memset(d, 0, sizeof(d));
cin >> n >> k;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < n; j++) {
cin >> mp[i][j];
}
mp[i][n] = mp[i][n + 1] = mp[i][n + 2] = mp[i][n + 3] = mp[i][n + 4] =
mp[i][n + 5] = mp[i][n + 6] = mp[i][n + 7] = '.';
}
flag = 0;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < n; j++) {
if (mp[i][j] == 's') {
flag = bfs(i, j);
}
}
}
if (flag)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
You are given string S and T consisting of lowercase English letters.
Determine if S equals T after rotation.
That is, determine if S equals T after the following operation is performed some number of times:
Operation: Let S = S_1 S_2 ... S_{|S|}. Change S to S_{|S|} S_1 S_2 ... S_{|S|-1}.
Here, |X| denotes the length of the string X.
Constraints
* 2 \leq |S| \leq 100
* |S| = |T|
* S and T consist of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
T
Output
If S equals T after rotation, print `Yes`; if it does not, print `No`.
Examples
Input
kyoto
tokyo
Output
Yes
Input
abc
arc
Output
No
Input
aaaaaaaaaaaaaaab
aaaaaaaaaaaaaaab
Output
Yes
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
string s1,s2;
cin>>s1>>s2;
int len = s1.length();
string s;
for(int i=0;i<len;i++){
s=s1.substr(i,len)+s1.substr(0,i);
if(s==s2){
cout<<"Yes"<<endl;
return 0;
}
}
cout<<"No"<<endl;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
After a probationary period in the game development company of IT City Petya was included in a group of the programmers that develops a new turn-based strategy game resembling the well known "Heroes of Might & Magic". A part of the game is turn-based fights of big squadrons of enemies on infinite fields where every cell is in form of a hexagon.
Some of magic effects are able to affect several field cells at once, cells that are situated not farther than n cells away from the cell in which the effect was applied. The distance between cells is the minimum number of cell border crosses on a path from one cell to another.
It is easy to see that the number of cells affected by a magic effect grows rapidly when n increases, so it can adversely affect the game performance. That's why Petya decided to write a program that can, given n, determine the number of cells that should be repainted after effect application, so that game designers can balance scale of the effects and the game performance. Help him to do it. Find the number of hexagons situated not farther than n cells away from a given cell.
<image>
Input
The only line of the input contains one integer n (0 β€ n β€ 109).
Output
Output one integer β the number of hexagons situated not farther than n cells away from a given cell.
Examples
Input
2
Output
19
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long s;
int n, i;
int main() {
cin >> n;
if (n % 2 == 0) {
s = n / 2;
s *= (n + 1);
} else {
s = (n + 1) / 2;
s *= n;
}
cout << 1 + s * 6 << '\n';
return 0;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
Jack has become a soldier now. Unfortunately, he has trouble with the drill. Instead of marching beginning with the left foot and then changing legs with each step, as ordered, he keeps repeating a sequence of steps, in which he sometimes makes the wrong steps or β horror of horrors! β stops for a while. For example, if Jack uses the sequence 'right, left, break', when the sergeant yells: 'Left! Right! Left! Right! Left! Right!', Jack first makes a step with the right foot, then one with the left foot, then he is confused and stops for a moment, then again - this time according to the order - starts with the right foot, then uses the left foot, then - to the sergeant's irritation - he stops to catch his breath, to incorrectly start with the right foot again... Marching this way, Jack will make the step that he is supposed to in the given moment in only one third of cases.
When the officers convinced him he should do something about it, Jack decided to modify the basic sequence of steps that he repeats. However, in order not to get too tired, he has decided that the only thing he'll do is adding any number of breaks in any positions of the original sequence (a break corresponds to stopping for the duration of one step). Of course, Jack can't make a step on the same foot twice in a row, if there is no pause between these steps. It is, however, not impossible that the sequence of steps he used so far is incorrect (it would explain a lot, actually).
Help Private Jack! Given the sequence of steps he keeps repeating, calculate the maximal percentage of time that he can spend marching correctly after adding some breaks to his scheme.
Input
The first line of input contains a sequence consisting only of characters 'L', 'R' and 'X', where 'L' corresponds to a step with the left foot, 'R' β with the right foot, and 'X' β to a break. The length of the sequence will not exceed 106.
Output
Output the maximum percentage of time that Jack can spend marching correctly, rounded down to exactly six digits after the decimal point.
Examples
Input
X
Output
0.000000
Input
LXRR
Output
50.000000
Note
In the second example, if we add two breaks to receive LXXRXR, Jack will march: LXXRXRLXXRXRL... instead of LRLRLRLRLRLRL... and will make the correct step in half the cases. If we didn't add any breaks, the sequence would be incorrect β Jack can't step on his right foot twice in a row.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T &k) {
k = 0;
int flag = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') flag = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
k = k * 10 + c - '0';
c = getchar();
}
k *= flag;
}
const int N = 2000005;
double f[N][2];
int n, m, k;
string s, t;
int main() {
cin >> s;
t = s[0];
n = s.length();
for (int i = 1; i < n; ++i) {
if (s[i] == s[i - 1] && s[i] != 'X') {
t += 'X';
t += s[i];
} else
t += s[i];
}
n = t.length();
if (t[0] == t[n - 1] && t[0] != 'X')
if (t[0] == 'L')
t += 'X';
else
t = 'X' + t;
n = t.length();
double l = 0, r = 1;
while (l + 1e-9 < r) {
double mid = (l + r) / 2;
f[0][0] = 0;
f[0][1] = -mid;
for (int i = 0; i < n; ++i) {
f[i + 1][0] = f[i][1] - mid;
f[i + 1][1] = f[i][0] - mid;
if (t[i] == 'L')
f[i + 1][1] = max(f[i + 1][1], f[i][0] + 1 - mid);
else if (t[i] == 'R')
f[i + 1][0] = max(f[i + 1][0], f[i][1] + 1 - mid);
f[i + 1][0] = max(f[i + 1][0], f[i + 1][1] - mid);
f[i + 1][1] = max(f[i + 1][1], f[i + 1][0] - mid);
}
if (f[n][0] > 0)
l = mid;
else
r = mid;
}
int x = (l + 1e-9) * 1e8;
printf("%d.%06d\n", x / 1000000, x % 1000000);
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
There are N turkeys. We number them from 1 through N.
M men will visit here one by one. The i-th man to visit will take the following action:
* If both turkeys x_i and y_i are alive: selects one of them with equal probability, then eats it.
* If either turkey x_i or y_i is alive (but not both): eats the alive one.
* If neither turkey x_i nor y_i is alive: does nothing.
Find the number of pairs (i,\ j) (1 β€ i < j β€ N) such that the following condition is held:
* The probability of both turkeys i and j being alive after all the men took actions, is greater than 0.
Constraints
* 2 β€ N β€ 400
* 1 β€ M β€ 10^5
* 1 β€ x_i < y_i β€ N
Input
Input is given from Standard Input in the following format:
N M
x_1 y_1
x_2 y_2
:
x_M y_M
Output
Print the number of pairs (i,\ j) (1 β€ i < j β€ N) such that the condition is held.
Examples
Input
3 1
1 2
Output
2
Input
4 3
1 2
3 4
2 3
Output
1
Input
3 2
1 2
1 2
Output
0
Input
10 10
8 9
2 8
4 6
4 9
7 8
2 8
1 8
3 4
3 4
2 7
Output
5
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n,m; bitset<400> S[400];
int x[200005], y[200005];
bool no[200005];
int main() {
scanf("%d%d", &n, &m);
for (int i=0; i<n; i++) S[i][i] = 1;
for (int i=0; i<m; i++) scanf("%d%d", &x[i], &y[i]), --x[i], --y[i];
for (int i=m-1; i>=0; i--) {
for (int j=0; j<n; j++) {
if (S[j][x[i]] && S[j][y[i]]) no[j] = 1;
else if (S[j][x[i]]) S[j][y[i]] = 1;
else if (S[j][y[i]]) S[j][x[i]] = 1;
}
}
int ans = 0;
for (int i=0; i<n-1; i++)
for (int j=i+1; j<n; j++)
if (!no[i] && !no[j] && !(S[i] & S[j]).count()) {
++ans;
}
printf("%d\n", ans);
return 0;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
Find the number of integers between 1 and K (inclusive) satisfying the following condition, modulo 10^9 + 7:
* The sum of the digits in base ten is a multiple of D.
Constraints
* All values in input are integers.
* 1 \leq K < 10^{10000}
* 1 \leq D \leq 100
Input
Input is given from Standard Input in the following format:
K
D
Output
Print the number of integers satisfying the condition, modulo 10^9 + 7.
Examples
Input
30
4
Output
6
Input
1000000009
1
Output
2
Input
98765432109876543210
58
Output
635270834
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
const int Mod=1e9+7;
char s[10010];
int d,l,f[10010][110];
void upd(int &x,int v)
{
x=(x+v)%Mod;
}
int main()
{
scanf("%s",s+1);
l=strlen(s+1);
scanf("%d",&d);
int sum=0;
for (int i=1;i<=l;i++)
{
for (int j=0;j<s[i]-'0';j++)
{
upd(f[i][(sum+j)%d],1);
}
sum=(sum+s[i]-'0')%d;
for (int j=0;j<d;j++)
{
for (int k=0;k<10;k++)
{
upd(f[i][(j+k)%d],f[i-1][j]);
}
}
/*
for (int j=0;j<d;j++)
{
cerr<<f[i][j]<<" ";
}
cerr<<endl;
*/
}
int res=f[l][0];
if (sum)
{
upd(res,Mod-1);
}
cout<<res<<endl;
return 0;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
A permutation β is a sequence of length n integers from 1 to n, in which all the numbers occur exactly once. For example, [1], [3, 5, 2, 1, 4], [1, 3, 2] β permutations, and [2, 3, 2], [4, 3, 1], [0] β no.
Polycarp was recently gifted a permutation a[1 ... n] of length n. Polycarp likes trees more than permutations, so he wants to transform permutation a into a rooted binary tree. He transforms an array of different integers into a tree as follows:
* the maximum element of the array becomes the root of the tree;
* all elements to the left of the maximum β form a left subtree (which is built according to the same rules but applied to the left part of the array), but if there are no elements to the left of the maximum, then the root has no left child;
* all elements to the right of the maximum β form a right subtree (which is built according to the same rules but applied to the right side of the array), but if there are no elements to the right of the maximum, then the root has no right child.
For example, if he builds a tree by permutation a=[3, 5, 2, 1, 4], then the root will be the element a_2=5, and the left subtree will be the tree that will be built for the subarray a[1 ... 1] = [3], and the right one β for the subarray a[3 ... 5] = [2, 1, 4]. As a result, the following tree will be built:
<image> The tree corresponding to the permutation a=[3, 5, 2, 1, 4].
Another example: let the permutation be a=[1, 3, 2, 7, 5, 6, 4]. In this case, the tree looks like this:
<image> The tree corresponding to the permutation a=[1, 3, 2, 7, 5, 6, 4].
Let us denote by d_v the depth of the vertex a_v, that is, the number of edges on the path from the root to the vertex numbered a_v. Note that the root depth is zero. Given the permutation a, for each vertex, find the value of d_v.
Input
The first line contains one integer t (1 β€ t β€ 100) β the number of test cases. Then t test cases follow.
The first line of each test case contains an integer n (1 β€ n β€ 100) β the length of the permutation.
This is followed by n numbers a_1, a_2, β¦, a_n β permutation a.
Output
For each test case, output n values β d_1, d_2, β¦, d_n.
Example
Input
3
5
3 5 2 1 4
1
1
4
4 3 1 2
Output
1 0 2 3 1
0
0 1 3 2
### Response
```cpp
#include<bits/stdc++.h>
#define ll long long
#define pb push_back
#define fi first
#define se second
#define mod 1000000007
#define setbits(x) __builtin_popcountll(x)
#define pii pair<long long int,long long int>
#define setp(x,y) fixed<<setprecision(y)<<x
#define print(ar,n); for(ll int i=0;i<n;i++) cout<<ar[i]<<" ";
#define take_array(ar,n) for(ll int i=0;i<n;i++) cin>>ar[i];
#define fast ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); cerr.tie(0);
using namespace std;
bool prime[1000005];
void sieve(){
memset(prime, true, sizeof(prime));
for (int p=2; p*p<=1000005; p++){
if (prime[p] == true) {
for (int i=p*p; i<=1000005; i += p)
prime[i] = false;
}
}
}
string toLower(string s){
for(int i=0;i<s.size();i++)
if(s[i]>='A' && s[i]<='Z') s[i]=s[i]+32;
return s;
}
map<int,int> mp;
void calC(int ar[],int low,int high,int dep,int n){
if(low>high) return;
int mx=INT_MIN,index=-1;
for(int i=low;i<=high;i++){
if(ar[i]>mx){
mx=ar[i];
index=i;
}
}
if(mp.find(index)==mp.end()) mp[index]=dep;
else return;
calC(ar,low,index-1,dep+1,n);
calC(ar,index+1,high,dep+1,n);
}
int main(){
#ifndef ONLINE_JUDGE
freopen("input.txt","r",stdin);
#endif
int t;
cin>>t;
while(t--){
mp.clear();
int n;
cin>>n;
int ar[n],i;
for(i=0;i<n;i++){
cin>>ar[i];
}
int dep=0;
calC(ar,0,n-1,dep,n);
for(map<int,int>::iterator i=mp.begin();i!=mp.end();i++){
cout<<i->second<<" ";
}
cout<<"\n";
}
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
You are given n non-decreasing arrays of non-negative numbers.
Vasya repeats the following operation k times:
* Selects a non-empty array.
* Puts the first element of the selected array in his pocket.
* Removes the first element from the selected array.
Vasya wants to maximize the sum of the elements in his pocket.
Input
The first line contains two integers n and k (1 β€ n, k β€ 3 000): the number of arrays and operations.
Each of the next n lines contain an array. The first integer in each line is t_i (1 β€ t_i β€ 10^6): the size of the i-th array. The following t_i integers a_{i, j} (0 β€ a_{i, 1} β€ β¦ β€ a_{i, t_i} β€ 10^8) are the elements of the i-th array.
It is guaranteed that k β€ β_{i=1}^n t_i β€ 10^6.
Output
Print one integer: the maximum possible sum of all elements in Vasya's pocket after k operations.
Example
Input
3 3
2 5 10
3 1 2 3
2 1 20
Output
26
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, k, m[3005];
long long _a[1010000], *ta = _a, *a[3005], s[3005], ans, h[15][3005];
void solve(int l, int r, int dep) {
if (l == r) {
for (int i = 0; i <= min(m[l], k); i++)
ans = max(ans, a[l][i] + h[dep][k - i]);
return;
}
int mid = (l + r) >> 1;
for (int j = 0; j <= k; j++) h[dep + 1][j] = h[dep][j];
for (int i = mid + 1; i <= r; i++)
for (int j = k; j >= m[i]; j--)
h[dep + 1][j] = max(h[dep + 1][j], h[dep + 1][j - m[i]] + s[i]);
solve(l, mid, dep + 1);
for (int j = 0; j <= k; j++) h[dep + 1][j] = h[dep][j];
for (int i = l; i <= mid; i++)
for (int j = k; j >= m[i]; j--)
h[dep + 1][j] = max(h[dep + 1][j], h[dep + 1][j - m[i]] + s[i]);
solve(mid + 1, r, dep + 1);
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &m[i]);
a[i] = ta;
ta += m[i] + 2;
for (int j = 1; j <= m[i]; j++) {
scanf("%d", &a[i][j]);
a[i][j] += a[i][j - 1];
}
s[i] += a[i][m[i]];
}
solve(1, n, 0);
printf("%lld", ans);
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
There is a new TV game on BerTV. In this game two players get a number A consisting of 2n digits. Before each turn players determine who will make the next move. Each player should make exactly n moves. On it's turn i-th player takes the leftmost digit of A and appends it to his or her number Si. After that this leftmost digit is erased from A. Initially the numbers of both players (S1 and S2) are Β«emptyΒ». Leading zeroes in numbers A, S1, S2 are allowed. In the end of the game the first player gets S1 dollars, and the second gets S2 dollars.
One day Homer and Marge came to play the game. They managed to know the number A beforehand. They want to find such sequence of their moves that both of them makes exactly n moves and which maximizes their total prize. Help them.
Input
The first line contains integer n (1 β€ n β€ 18). The second line contains integer A consisting of exactly 2n digits. This number can have leading zeroes.
Output
Output the line of 2n characters Β«HΒ» and Β«MΒ» β the sequence of moves of Homer and Marge, which gives them maximum possible total prize. Each player must make exactly n moves. If there are several solutions, output any of them.
Examples
Input
2
1234
Output
HHMM
Input
2
9911
Output
HMHM
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
const int INF = 0x3f3f3f3f;
const ll INFLL = 0x3f3f3f3f3f3f3f3f;
ll dp[19][19];
ll n;
ll tpow[19];
string s;
vector<char> ans[19][19];
ll arr[40];
int main() {
cin.tie(0)->sync_with_stdio(0);
cin >> n;
cin >> s;
tpow[0] = 1;
for (int i = (1); i < 19; ++i) {
tpow[i] = tpow[i - 1] * 10LL;
}
for (int i = (0); i < 2 * n; ++i) {
arr[i] = s[i] - '0';
}
for (int i = (0); i < 19; ++i) {
for (int j = (0); j < 19; ++j) {
dp[i][j] = -1;
}
}
dp[0][0] = 0;
for (int i = 2 * n - 1; i >= (0); --i) {
for (int j = (0); j < n + 1; ++j) {
if (j > n || (2 * n - 1 - i) - j > n || (2 * n - 1 - i) - j < 0) continue;
if (j + 1 <= n) {
if (dp[j][(2 * n - 1 - i) - j] + arr[i] * tpow[j] >
dp[j + 1][(2 * n - 1 - i) - j]) {
dp[j + 1][(2 * n - 1 - i) - j] =
dp[j][(2 * n - 1 - i) - j] + arr[i] * tpow[j];
ans[j + 1][(2 * n - 1 - i) - j] = ans[j][(2 * n - 1 - i) - j];
ans[j + 1][(2 * n - 1 - i) - j].push_back('H');
}
}
if ((2 * n - 1 - i) - j + 1 <= n) {
if (dp[j][(2 * n - 1 - i) - j] + arr[i] * tpow[(2 * n - 1 - i) - j] >
dp[j][(2 * n - 1 - i) - j + 1]) {
dp[j][(2 * n - 1 - i) - j + 1] =
dp[j][(2 * n - 1 - i) - j] + arr[i] * tpow[(2 * n - 1 - i) - j];
ans[j][(2 * n - 1 - i) - j + 1] = ans[j][(2 * n - 1 - i - j)];
ans[j][(2 * n - 1 - i) - j + 1].push_back('M');
}
}
}
}
reverse(ans[n][n].begin(), ans[n][n].end());
for (auto p : ans[n][n]) {
cout << p;
}
return 0;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
Princess Twilight went to Celestia and Luna's old castle to research the chest from the Elements of Harmony.
<image>
A sequence of positive integers bi is harmony if and only if for every two elements of the sequence their greatest common divisor equals 1. According to an ancient book, the key of the chest is a harmony sequence bi which minimizes the following expression:
<image>
You are given sequence ai, help Princess Twilight to find the key.
Input
The first line contains an integer n (1 β€ n β€ 100) β the number of elements of the sequences a and b. The next line contains n integers a1, a2, ..., an (1 β€ ai β€ 30).
Output
Output the key β sequence bi that minimizes the sum described above. If there are multiple optimal sequences, you can output any of them.
Examples
Input
5
1 1 1 1 1
Output
1 1 1 1 1
Input
5
1 6 4 2 8
Output
1 5 3 1 8
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int prime[] = {2, 3, 5, 7, 11, 13, 17, 19,
23, 29, 31, 37, 41, 43, 47, 53};
const int inf = 0x3f3f3f3f;
int n, a[200], ans[200];
int dp[200][80000], contain[60], ans1[200][80000], pre[200][80000];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
int li = 1 << 16;
memset(dp, 0x3f, sizeof(dp));
for (int nu = 1; nu < 60; nu++)
for (int i = 0; i < 16; i++)
if (nu % prime[i] == 0) contain[nu] |= (1 << i);
dp[0][0] = 0;
for (int i = 1; i <= n; i++)
for (int nu = 1; nu < 60; nu++)
for (int s = 0; s < li; s++) {
if (!(s & contain[nu]) &&
dp[i][s | contain[nu]] > dp[i - 1][s] + abs(a[i] - nu)) {
int nes = s | contain[nu];
dp[i][nes] = dp[i - 1][s] + abs(a[i] - nu);
ans1[i][nes] = nu;
pre[i][nes] = s;
}
}
int minn = inf, finalstate = 0;
for (int s = 0; s < li; s++) {
if (minn > dp[n][s]) {
minn = dp[n][s];
finalstate = s;
}
}
for (int i = n; i >= 1; i--) {
ans[i] = ans1[i][finalstate];
finalstate = pre[i][finalstate];
}
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
Alyona decided to go on a diet and went to the forest to get some apples. There she unexpectedly found a magic rooted tree with root in the vertex 1, every vertex and every edge of which has a number written on.
The girl noticed that some of the tree's vertices are sad, so she decided to play with them. Let's call vertex v sad if there is a vertex u in subtree of vertex v such that dist(v, u) > au, where au is the number written on vertex u, dist(v, u) is the sum of the numbers written on the edges on the path from v to u.
Leaves of a tree are vertices connected to a single vertex by a single edge, but the root of a tree is a leaf if and only if the tree consists of a single vertex β root.
Thus Alyona decided to remove some of tree leaves until there will be no any sad vertex left in the tree. What is the minimum number of leaves Alyona needs to remove?
Input
In the first line of the input integer n (1 β€ n β€ 105) is given β the number of vertices in the tree.
In the second line the sequence of n integers a1, a2, ..., an (1 β€ ai β€ 109) is given, where ai is the number written on vertex i.
The next n - 1 lines describe tree edges: ith of them consists of two integers pi and ci (1 β€ pi β€ n, - 109 β€ ci β€ 109), meaning that there is an edge connecting vertices i + 1 and pi with number ci written on it.
Output
Print the only integer β the minimum number of leaves Alyona needs to remove such that there will be no any sad vertex left in the tree.
Example
Input
9
88 22 83 14 95 91 98 53 11
3 24
7 -8
1 67
1 64
9 65
5 12
6 -80
3 8
Output
5
Note
The following image represents possible process of removing leaves from the tree:
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-8;
const long long SZ = 100010, one = 1, INF = 0x7FFFFFFF, mod = 1000000007,
S = 207, T = 208;
long long n, arr[SZ];
struct nd {
long long to, wt;
nd(long long a = 0, long long b = 0) : to(a), wt(b) {}
};
vector<nd> mp[SZ];
void init() {
cin >> n;
for (long long i = 1; i <= n; ++i) cin >> arr[i];
for (long long i = 2; i <= n; ++i) {
long long a, b;
cin >> a >> b;
mp[a].push_back(nd(i, b));
mp[i].push_back(nd(a, b));
}
}
void dfs(long long x, long long p, long long maxv, long long &y) {
if (maxv > arr[x])
return;
else {
++y;
for (long long i = 0; i < mp[x].size(); ++i) {
long long to = mp[x][i].to, wt = mp[x][i].wt;
if (to != p) {
dfs(to, x, max(0LL, wt + maxv), y);
}
}
}
}
void work() {
long long res = 0;
dfs(1, -1, 0, res);
cout << n - res << endl;
}
int main() {
std::ios::sync_with_stdio(0);
long long casenum;
{
init();
work();
}
return 0;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
On some square in the lowest row of a chessboard a stands a pawn. It has only two variants of moving: upwards and leftwards or upwards and rightwards. The pawn can choose from which square of the lowest row it can start its journey. On each square lay from 0 to 9 peas. The pawn wants to reach the uppermost row having collected as many peas as possible. As there it will have to divide the peas between itself and its k brothers, the number of peas must be divisible by k + 1. Find the maximal number of peas it will be able to collect and which moves it should make to do it.
The pawn cannot throw peas away or leave the board. When a pawn appears in some square of the board (including the first and last square of the way), it necessarily takes all the peas.
Input
The first line contains three integers n, m, k (2 β€ n, m β€ 100, 0 β€ k β€ 10) β the number of rows and columns on the chessboard, the number of the pawn's brothers. Then follow n lines containing each m numbers from 0 to 9 without spaces β the chessboard's description. Each square is described by one number β the number of peas in it. The first line corresponds to the uppermost row and the last line β to the lowest row.
Output
If it is impossible to reach the highest row having collected the number of peas divisible by k + 1, print -1.
Otherwise, the first line must contain a single number β the maximal number of peas the pawn can collect given that the number must be divisible by k + 1. The second line must contain a single number β the number of the square's column in the lowest row, from which the pawn must start its journey. The columns are numbered from the left to the right with integral numbers starting from 1. The third line must contain a line consisting of n - 1 symbols β the description of the pawn's moves. If the pawn must move upwards and leftwards, print L, if it must move upwards and rightwards, print R. If there are several solutions to that problem, print any of them.
Examples
Input
3 3 1
123
456
789
Output
16
2
RL
Input
3 3 0
123
456
789
Output
17
3
LR
Input
2 2 10
98
75
Output
-1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int dp[128][128][15];
int board[128][128];
int dy[] = {-1, 1};
int N, M, K;
int solve(int x, int y, int k) {
if (dp[x][y][k] != -2) return dp[x][y][k];
if (x == 0) {
if (board[x][y] % K == k)
return dp[x][y][k] = board[x][y];
else
return dp[x][y][k] = -1;
}
int curr = board[x][y];
int ans = -1;
int req = (K + k - (curr % K)) % K;
for (int i = 0; i < 2; i++) {
int nx = x - 1, ny = y + dy[i];
if (nx < 0 || ny < 0 || nx >= N || ny >= M) continue;
int ret = solve(nx, ny, req);
if (ret != -1) {
ans = max(ans, curr + ret);
}
}
return dp[x][y][k] = ans;
}
void print(int x, int y, int k) {
int curr = board[x][y];
int req = (K + k - (curr % K)) % K;
for (int i = 0; i < 2; i++) {
int nx = x - 1, ny = y + dy[i];
if (nx < 0 || ny < 0 || nx >= N || ny >= M) continue;
if (dp[x][y][k] == curr + dp[nx][ny][req]) {
if (i == 0)
cout << "L";
else
cout << "R";
print(nx, ny, req);
return;
}
}
}
int main() {
cin >> N >> M >> K;
K += 1;
for (int i = 0; i < N; i++) {
string s;
cin >> s;
for (int j = 0; j < M; j++) board[i][j] = s[j] - '0';
}
for (int i = 0; i < N; i++)
for (int j = 0; j < M; j++)
for (int k = 0; k < K; k++) dp[i][j][k] = -2;
int ans = -1;
int maxI = 0;
for (int i = 0; i < M; i++) {
int ret = solve(N - 1, i, 0);
if (ret != -1 && ret > ans) {
ans = ret;
maxI = i;
}
}
if (ans == -1) {
cout << -1 << endl;
return 0;
}
cout << ans << endl;
cout << maxI + 1 << endl;
print(N - 1, maxI, 0);
cout << endl;
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
N people are waiting in a single line in front of the Takahashi Store. The cash on hand of the i-th person from the front of the line is a positive integer A_i.
Mr. Takahashi, the shop owner, has decided on the following scheme: He picks a product, sets a positive integer P indicating its price, and shows this product to customers in order, starting from the front of the line. This step is repeated as described below.
At each step, when a product is shown to a customer, if price P is equal to or less than the cash held by that customer at the time, the customer buys the product and Mr. Takahashi ends the current step. That is, the cash held by the first customer in line with cash equal to or greater than P decreases by P, and the next step begins.
Mr. Takahashi can set the value of positive integer P independently at each step.
He would like to sell as many products as possible. However, if a customer were to end up with 0 cash on hand after a purchase, that person would not have the fare to go home. Customers not being able to go home would be a problem for Mr. Takahashi, so he does not want anyone to end up with 0 cash.
Help out Mr. Takahashi by writing a program that determines the maximum number of products he can sell, when the initial cash in possession of each customer is given.
Constraints
* 1 β¦ | N | β¦ 100000
* 1 β¦ A_i β¦ 10^9(1 β¦ i β¦ N)
* All inputs are integers.
Input
Inputs are provided from Standard Inputs in the following form.
N
A_1
:
A_N
Output
Output an integer representing the maximum number of products Mr. Takahashi can sell.
Examples
Input
3
3
2
5
Output
3
Input
15
3
1
4
1
5
9
2
6
5
3
5
8
9
7
9
Output
18
### Response
```cpp
#include <cstdio>
#include <iostream>
#include <algorithm>
#include <string>
using namespace std;
typedef long long ll;
int n;
ll a[111111];
int main(void){
cin >> n;
for(int i = 0; i < n; i++){
cin >> a[i];
}
ll ans = 0;
ll k = 1;
for(int i = 0; i < n; i++){
if(a[i] > k){
ans += (a[i]-1)/k;
k = max(k,2LL);
}else if(a[i] == k){
k++;
}
}
cout << ans << endl;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
The Berland Forest can be represented as an infinite cell plane. Every cell contains a tree. That is, contained before the recent events.
A destructive fire raged through the Forest, and several trees were damaged by it. Precisely speaking, you have a n Γ m rectangle map which represents the damaged part of the Forest. The damaged trees were marked as "X" while the remaining ones were marked as ".". You are sure that all burnt trees are shown on the map. All the trees outside the map are undamaged.
The firemen quickly extinguished the fire, and now they are investigating the cause of it. The main version is that there was an arson: at some moment of time (let's consider it as 0) some trees were set on fire. At the beginning of minute 0, only the trees that were set on fire initially were burning. At the end of each minute, the fire spread from every burning tree to each of 8 neighboring trees. At the beginning of minute T, the fire was extinguished.
The firemen want to find the arsonists as quickly as possible. The problem is, they know neither the value of T (how long the fire has been raging) nor the coordinates of the trees that were initially set on fire. They want you to find the maximum value of T (to know how far could the arsonists escape) and a possible set of trees that could be initially set on fire.
Note that you'd like to maximize value T but the set of trees can be arbitrary.
Input
The first line contains two integer n and m (1 β€ n, m β€ 10^6, 1 β€ n β
m β€ 10^6) β the sizes of the map.
Next n lines contain the map. The i-th line corresponds to the i-th row of the map and contains m-character string. The j-th character of the i-th string is "X" if the corresponding tree is burnt and "." otherwise.
It's guaranteed that the map contains at least one "X".
Output
In the first line print the single integer T β the maximum time the Forest was on fire. In the next n lines print the certificate: the map (n Γ m rectangle) where the trees that were set on fire are marked as "X" and all other trees are marked as ".".
Examples
Input
3 6
XXXXXX
XXXXXX
XXXXXX
Output
1
......
.X.XX.
......
Input
10 10
.XXXXXX...
.XXXXXX...
.XXXXXX...
.XXXXXX...
.XXXXXXXX.
...XXXXXX.
...XXXXXX.
...XXXXXX.
...XXXXXX.
..........
Output
2
..........
..........
...XX.....
..........
..........
..........
.....XX...
..........
..........
..........
Input
4 5
X....
..XXX
..XXX
..XXX
Output
0
X....
..XXX
..XXX
..XXX
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void maxtt(T& t1, T t2) {
t1 = max(t1, t2);
}
template <typename T>
void mintt(T& t1, T t2) {
t1 = min(t1, t2);
}
bool debug = 0;
int n, m, k;
string direc = "URDL";
const long long MOD2 = (long long)1000000007 * (long long)1000000007;
long long ln, lk, lm;
void etp(bool f = 0) {
puts(f ? "YES" : "NO");
exit(0);
}
void addmod(int& x, int y, int mod = 1000000007) {
x += y;
if (x >= mod) x -= mod;
if (x < 0) x += mod;
assert(x >= 0 && x < mod);
}
void et(int x = -1) {
printf("%d\n", x);
exit(0);
}
long long fastPow(long long x, long long y, int mod = 1000000007) {
long long ans = 1;
while (y > 0) {
if (y & 1) ans = (x * ans) % mod;
x = x * x % mod;
y >>= 1;
}
return ans;
}
long long gcd1(long long x, long long y) { return y ? gcd1(y, x % y) : x; }
char s[1000035];
vector<int> mp[1000035], ps[1000035], ot[1000035];
int area(int a, int b, int c, int d) {
return mp[c][d] - mp[a - 1][d] - mp[c][b - 1] + mp[a - 1][b - 1];
}
bool ck(int T, bool fg) {
int len = T * 2 + 1;
for (int(i) = 1; (i) <= (int)(n); (i)++)
for (int(j) = 1; (j) <= (int)(m); (j)++) ps[i][j] = 0;
for (int(i) = 1; (i) <= (int)(n + 1 - len); (i)++)
for (int(j) = 1; (j) <= (int)(m + 1 - len); (j)++)
if (area(i, j, i, j) == 1) {
if (area(i, j, i + len - 1, j + len - 1) == len * len) {
if (fg) {
ot[i + T][j + T] = 1;
}
ps[i][j]++;
ps[i][j + len]--;
ps[i + len][j]--;
ps[i + len][j + len]++;
}
}
for (int(i) = 1; (i) <= (int)(n); (i)++) {
for (int(j) = 1; (j) <= (int)(m); (j)++)
ps[i][j] += ps[i][j - 1] + ps[i - 1][j] - ps[i - 1][j - 1];
}
for (int(i) = 1; (i) <= (int)(n); (i)++)
for (int(j) = 1; (j) <= (int)(m); (j)++) {
bool isx = area(i, j, i, j);
bool isy = ps[i][j] >= 1;
if (isx != isy) return 0;
}
return 1;
}
void fmain(int tid) {
scanf("%d%d", &n, &m);
for (int(i) = 0; (i) < (int)(n + 2); (i)++) {
mp[i].resize(m + 5, 0);
ps[i].resize(m + 5, 0);
ot[i].resize(m + 5, 0);
}
for (int(i) = 1; (i) <= (int)(n); (i)++) {
scanf("%s", s + 1);
for (int(j) = 1; (j) <= (int)(m); (j)++)
if (s[j] == 'X') mp[i][j] = 1;
for (int(j) = 1; (j) <= (int)(m); (j)++)
mp[i][j] += mp[i][j - 1] + mp[i - 1][j] - mp[i - 1][j - 1];
}
int l = 0, r = max(m, n);
while (l + 1 < r) {
int mid = (l + r) / 2;
if (ck(mid, 0))
l = mid;
else
r = mid - 1;
}
int ans = ck(r, 0) ? r : l;
printf("%d\n", ans);
ck(ans, 1);
for (int(i) = 1; (i) <= (int)(n); (i)++) {
for (int(j) = 1; (j) <= (int)(m); (j)++) printf("%c", ot[i][j] ? 'X' : '.');
puts("");
}
}
int main() {
int t = 1;
for (int(i) = 1; (i) <= (int)(t); (i)++) {
fmain(i);
}
return 0;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
The Looksery company, consisting of n staff members, is planning another big party. Every employee has his phone number and the phone numbers of his friends in the phone book. Everyone who comes to the party, sends messages to his contacts about how cool it is. At the same time everyone is trying to spend as much time on the fun as possible, so they send messages to everyone without special thinking, moreover, each person even sends a message to himself or herself.
Igor and Max, Looksery developers, started a dispute on how many messages each person gets. Igor indicates n numbers, the i-th of which indicates how many messages, in his view, the i-th employee is going to take. If Igor guesses correctly at least one of these numbers, he wins, otherwise Max wins.
You support Max in this debate, so you need, given the contact lists of the employees, to determine whether there is a situation where Igor loses. Specifically, you need to determine which employees should come to the party, and which should not, so after all the visitors send messages to their contacts, each employee received a number of messages that is different from what Igor stated.
Input
The first line contains a single integer n (1 β€ n β€ 100) β the number of employees of company Looksery.
Next n lines contain the description of the contact lists of the employees. The i-th of these lines contains a string of length n, consisting of digits zero and one, specifying the contact list of the i-th employee. If the j-th character of the i-th string equals 1, then the j-th employee is in the i-th employee's contact list, otherwise he isn't. It is guaranteed that the i-th character of the i-th line is always equal to 1.
The last line contains n space-separated integers: a1, a2, ..., an (0 β€ ai β€ n), where ai represents the number of messages that the i-th employee should get according to Igor.
Output
In the first line print a single integer m β the number of employees who should come to the party so that Igor loses the dispute.
In the second line print m space-separated integers β the numbers of these employees in an arbitrary order.
If Igor wins the dispute in any case, print -1.
If there are multiple possible solutions, print any of them.
Examples
Input
3
101
010
001
0 1 2
Output
1
1
Input
1
1
1
Output
0
Input
4
1111
0101
1110
0001
1 0 1 0
Output
4
1 2 3 4
Note
In the first sample Igor supposes that the first employee will receive 0 messages. Since he isn't contained in any other contact list he must come to the party in order to receive one message from himself. If he is the only who come to the party then he will receive 1 message, the second employee will receive 0 messages and the third will also receive 1 message. Thereby Igor won't guess any number.
In the second sample if the single employee comes to the party he receives 1 message and Igor wins, so he shouldn't do it.
In the third sample the first employee will receive 2 messages, the second β 3, the third β 2, the fourth β 3.
### Response
```cpp
#include <bits/stdc++.h>
int main() {
std::ios_base::sync_with_stdio(false);
int n;
std::cin >> n;
std::vector<std::vector<bool> > g(n, std::vector<bool>(n, 0));
for (int row = 0; row < n; row++) {
std::string s;
std::cin >> s;
for (int col = 0; col < s.size(); col++) {
g[row][col] = s[col] - '0';
}
}
std::vector<int> a(n);
for (int p = 0; p < n; p++) {
std::cin >> a[p];
}
bool done(false);
std::vector<int> guests;
while (!done) {
done = true;
for (int p = 0; p < n; p++) {
if (a[p] != 0) {
continue;
}
done = false;
guests.push_back(p);
for (int q = 0; q < n; q++) {
a[q] -= g[p][q];
}
break;
}
}
std::cout << guests.size() << std::endl;
for (int p = 0; p < guests.size(); p++) {
std::cout << (1 + guests[p]) << std::endl;
}
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
Polycarp loves ciphers. He has invented his own cipher called Right-Left.
Right-Left cipher is used for strings. To encrypt the string s=s_{1}s_{2} ... s_{n} Polycarp uses the following algorithm:
* he writes down s_1,
* he appends the current word with s_2 (i.e. writes down s_2 to the right of the current result),
* he prepends the current word with s_3 (i.e. writes down s_3 to the left of the current result),
* he appends the current word with s_4 (i.e. writes down s_4 to the right of the current result),
* he prepends the current word with s_5 (i.e. writes down s_5 to the left of the current result),
* and so on for each position until the end of s.
For example, if s="techno" the process is: "t" β "te" β "cte" β "cteh" β "ncteh" β "ncteho". So the encrypted s="techno" is "ncteho".
Given string t β the result of encryption of some string s. Your task is to decrypt it, i.e. find the string s.
Input
The only line of the input contains t β the result of encryption of some string s. It contains only lowercase Latin letters. The length of t is between 1 and 50, inclusive.
Output
Print such string s that after encryption it equals t.
Examples
Input
ncteho
Output
techno
Input
erfdcoeocs
Output
codeforces
Input
z
Output
z
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string t, s = "";
cin >> t;
int x, y;
if (t.length() % 2 == 0) {
x = t.length() / 2 - 1;
} else {
x = t.length() / 2;
}
y = x + 1;
while (true) {
if (x >= 0) {
s += t[x];
}
if (s.length() == t.length()) {
break;
}
if (y < t.length()) {
s += t[y];
}
if (s.length() == t.length()) {
break;
}
x--;
y++;
}
cout << s << '\n';
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
Suppose that you are in a campus and have to go for classes day by day. As you may see, when you hurry to a classroom, you surprisingly find that many seats there are already occupied. Today you and your friends went for class, and found out that some of the seats were occupied.
The classroom contains n rows of seats and there are m seats in each row. Then the classroom can be represented as an n Γ m matrix. The character '.' represents an empty seat, while '*' means that the seat is occupied. You need to find k consecutive empty seats in the same row or column and arrange those seats for you and your friends. Your task is to find the number of ways to arrange the seats. Two ways are considered different if sets of places that students occupy differs.
Input
The first line contains three positive integers n,m,k (1 β€ n, m, k β€ 2 000), where n,m represent the sizes of the classroom and k is the number of consecutive seats you need to find.
Each of the next n lines contains m characters '.' or '*'. They form a matrix representing the classroom, '.' denotes an empty seat, and '*' denotes an occupied seat.
Output
A single number, denoting the number of ways to find k empty seats in the same row or column.
Examples
Input
2 3 2
**.
...
Output
3
Input
1 2 2
..
Output
1
Input
3 3 4
.*.
*.*
.*.
Output
0
Note
In the first sample, there are three ways to arrange those seats. You can take the following seats for your arrangement.
* (1,3), (2,3)
* (2,2), (2,3)
* (2,1), (2,2)
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<int> v, res;
int main() {
ios::sync_with_stdio(false);
int n, m, k;
cin >> n >> m >> k;
char c[n + 10][m + 10];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> c[i][j];
}
}
long long res = 0;
for (int i = 0; i < n; i++) {
int sum = 0;
for (int j = 0; j < m; j++) {
if (c[i][j] == '.')
sum++;
else {
if (sum >= k) {
res++;
sum -= k;
res += sum;
}
sum = 0;
}
}
if (sum >= k) {
res++;
sum -= k;
res += sum;
}
}
for (int i = 0; i < m; i++) {
int sum = 0;
for (int j = 0; j < n; j++) {
if (c[j][i] == '.')
sum++;
else {
if (sum >= k) {
res++;
sum -= k;
res += sum;
}
sum = 0;
}
}
if (sum >= k) {
res++;
sum -= k;
res += sum;
}
}
if (k == 1)
cout << res / 2;
else
cout << res;
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
A film festival is coming up in the city N. The festival will last for exactly n days and each day will have a premiere of exactly one film. Each film has a genre β an integer from 1 to k.
On the i-th day the festival will show a movie of genre ai. We know that a movie of each of k genres occurs in the festival programme at least once. In other words, each integer from 1 to k occurs in the sequence a1, a2, ..., an at least once.
Valentine is a movie critic. He wants to watch some movies of the festival and then describe his impressions on his site.
As any creative person, Valentine is very susceptive. After he watched the movie of a certain genre, Valentine forms the mood he preserves until he watches the next movie. If the genre of the next movie is the same, it does not change Valentine's mood. If the genres are different, Valentine's mood changes according to the new genre and Valentine has a stress.
Valentine can't watch all n movies, so he decided to exclude from his to-watch list movies of one of the genres. In other words, Valentine is going to choose exactly one of the k genres and will skip all the movies of this genre. He is sure to visit other movies.
Valentine wants to choose such genre x (1 β€ x β€ k), that the total number of after-movie stresses (after all movies of genre x are excluded) were minimum.
Input
The first line of the input contains two integers n and k (2 β€ k β€ n β€ 105), where n is the number of movies and k is the number of genres.
The second line of the input contains a sequence of n positive integers a1, a2, ..., an (1 β€ ai β€ k), where ai is the genre of the i-th movie. It is guaranteed that each number from 1 to k occurs at least once in this sequence.
Output
Print a single number β the number of the genre (from 1 to k) of the excluded films. If there are multiple answers, print the genre with the minimum number.
Examples
Input
10 3
1 1 2 3 2 3 3 1 1 3
Output
3
Input
7 3
3 1 3 2 3 1 2
Output
1
Note
In the first sample if we exclude the movies of the 1st genre, the genres 2, 3, 2, 3, 3, 3 remain, that is 3 stresses; if we exclude the movies of the 2nd genre, the genres 1, 1, 3, 3, 3, 1, 1, 3 remain, that is 3 stresses; if we exclude the movies of the 3rd genre the genres 1, 1, 2, 2, 1, 1 remain, that is 2 stresses.
In the second sample whatever genre Valentine excludes, he will have exactly 3 stresses.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, k;
int inp[100001];
int subtract[100001];
int main() {
cin >> n >> k;
int index = 1;
for (int i = 1; i <= n; i++) {
int tmp;
cin >> tmp;
if (inp[index - 1] != tmp) {
inp[index++] = tmp;
}
}
for (int i = 1; i < index; i++) {
if (i == 1 || i == index - 1) {
subtract[inp[i]] += 1;
} else {
subtract[inp[i]] += 2 - (inp[i - 1] != inp[i + 1]);
}
}
int ans = 1000000;
int ans_index = -1;
for (int i = 1; i <= k; i++) {
if (index - 2 - subtract[i] < ans) {
ans = index - 2 - subtract[i];
ans_index = i;
}
}
cout << ans_index << endl;
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
Arkady decides to observe a river for n consecutive days. The river's water level on each day is equal to some real value.
Arkady goes to the riverside each day and makes a mark on the side of the channel at the height of the water level, but if it coincides with a mark made before, no new mark is created. The water does not wash the marks away. Arkady writes down the number of marks strictly above the water level each day, on the i-th day this value is equal to mi.
Define di as the number of marks strictly under the water level on the i-th day. You are to find out the minimum possible sum of di over all days. There are no marks on the channel before the first day.
Input
The first line contains a single positive integer n (1 β€ n β€ 105) β the number of days.
The second line contains n space-separated integers m1, m2, ..., mn (0 β€ mi < i) β the number of marks strictly above the water on each day.
Output
Output one single integer β the minimum possible sum of the number of marks strictly below the water level among all days.
Examples
Input
6
0 1 0 3 0 2
Output
6
Input
5
0 1 2 1 2
Output
1
Input
5
0 1 1 2 2
Output
0
Note
In the first example, the following figure shows an optimal case.
<image>
Note that on day 3, a new mark should be created because if not, there cannot be 3 marks above water on day 4. The total number of marks underwater is 0 + 0 + 2 + 0 + 3 + 1 = 6.
In the second example, the following figure shows an optimal case.
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int a[N], d[N];
int main() {
int n;
scanf("%d", &n);
stack<int> s;
int cur = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
s.push(i);
if (a[i] + 1 > cur) {
int need = a[i] + 1 - cur;
while (need--) {
d[s.top()] = 1;
s.pop();
cur++;
}
}
}
long long ans = 0;
int marks = 0;
for (int i = 1; i <= n; i++) {
marks += d[i];
ans += marks - a[i] - 1;
}
printf("%lld\n", ans);
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
This is the easy version of the problem. The difference between the versions is the constraint on n and the required number of operations. You can make hacks only if all versions of the problem are solved.
There are two binary strings a and b of length n (a binary string is a string consisting of symbols 0 and 1). In an operation, you select a prefix of a, and simultaneously invert the bits in the prefix (0 changes to 1 and 1 changes to 0) and reverse the order of the bits in the prefix.
For example, if a=001011 and you select the prefix of length 3, it becomes 011011. Then if you select the entire string, it becomes 001001.
Your task is to transform the string a into b in at most 3n operations. It can be proved that it is always possible.
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 a single integer n (1β€ nβ€ 1000) β the length of the binary strings.
The next two lines contain two binary strings a and b of length n.
It is guaranteed that the sum of n across all test cases does not exceed 1000.
Output
For each test case, output an integer k (0β€ kβ€ 3n), followed by k integers p_1,β¦,p_k (1β€ p_iβ€ n). Here k is the number of operations you use and p_i is the length of the prefix you flip in the i-th operation.
Example
Input
5
2
01
10
5
01011
11100
2
01
01
10
0110011011
1000110100
1
0
1
Output
3 1 2 1
6 5 2 5 3 1 2
0
9 4 1 2 10 4 1 2 1 5
1 1
Note
In the first test case, we have 01β 11β 00β 10.
In the second test case, we have 01011β 00101β 11101β 01000β 10100β 00100β 11100.
In the third test case, the strings are already the same. Another solution is to flip the prefix of length 2, which will leave a unchanged.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int qq;
cin >> qq;
while (qq--) {
int n;
cin >> n;
string a, b;
cin >> a >> b;
vector<int> v;
for (int i = n - 1; i >= 0; i--) {
if (a[i] != b[i]) {
if (b[i] != a[0]) {
reverse(a.begin(), a.begin() + i + 1);
for (int j = 0; j <= i; j++) {
if (a[j] == '1')
a[j] = '0';
else
a[j] = '1';
}
v.push_back(i + 1);
} else {
v.push_back(1);
if (a[0] == '1')
a[0] = '0';
else
a[0] = '1';
reverse(a.begin(), a.begin() + i + 1);
for (int j = 0; j <= i; j++) {
if (a[j] == '1')
a[j] = '0';
else
a[j] = '1';
}
v.push_back(i + 1);
}
}
}
if (v.empty()) {
cout << "0" << endl;
continue;
}
cout << v.size() << " ";
for (auto i : v) cout << i << " ";
cout << endl;
}
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
Recently, Tokitsukaze found an interesting game. Tokitsukaze had n items at the beginning of this game. However, she thought there were too many items, so now she wants to discard m (1 β€ m β€ n) special items of them.
These n items are marked with indices from 1 to n. In the beginning, the item with index i is placed on the i-th position. Items are divided into several pages orderly, such that each page contains exactly k positions and the last positions on the last page may be left empty.
Tokitsukaze would do the following operation: focus on the first special page that contains at least one special item, and at one time, Tokitsukaze would discard all special items on this page. After an item is discarded or moved, its old position would be empty, and then the item below it, if exists, would move up to this empty position. The movement may bring many items forward and even into previous pages, so Tokitsukaze would keep waiting until all the items stop moving, and then do the operation (i.e. check the special page and discard the special items) repeatedly until there is no item need to be discarded.
<image> Consider the first example from the statement: n=10, m=4, k=5, p=[3, 5, 7, 10]. The are two pages. Initially, the first page is special (since it is the first page containing a special item). So Tokitsukaze discards the special items with indices 3 and 5. After, the first page remains to be special. It contains [1, 2, 4, 6, 7], Tokitsukaze discards the special item with index 7. After, the second page is special (since it is the first page containing a special item). It contains [9, 10], Tokitsukaze discards the special item with index 10.
Tokitsukaze wants to know the number of operations she would do in total.
Input
The first line contains three integers n, m and k (1 β€ n β€ 10^{18}, 1 β€ m β€ 10^5, 1 β€ m, k β€ n) β the number of items, the number of special items to be discarded and the number of positions in each page.
The second line contains m distinct integers p_1, p_2, β¦, p_m (1 β€ p_1 < p_2 < β¦ < p_m β€ n) β the indices of special items which should be discarded.
Output
Print a single integer β the number of operations that Tokitsukaze would do in total.
Examples
Input
10 4 5
3 5 7 10
Output
3
Input
13 4 5
7 8 9 10
Output
1
Note
For the first example:
* In the first operation, Tokitsukaze would focus on the first page [1, 2, 3, 4, 5] and discard items with indices 3 and 5;
* In the second operation, Tokitsukaze would focus on the first page [1, 2, 4, 6, 7] and discard item with index 7;
* In the third operation, Tokitsukaze would focus on the second page [9, 10] and discard item with index 10.
For the second example, Tokitsukaze would focus on the second page [6, 7, 8, 9, 10] and discard all special items at once.
### Response
```cpp
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse4")
using namespace std;
template <class T>
bool ckmin(T& a, const T& b) {
return b < a ? a = b, 1 : 0;
}
template <class T>
bool ckmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int MOD = 1000000007;
const char nl = '\n';
const int MX = 100001;
void solve() {
long long N;
int M;
long long K;
cin >> N >> M >> K;
vector<long long> A(M);
for (int i = 0; i < (M); i++) cin >> A[i];
for (int i = 0; i < (M); i++) A[i]--;
int p = 0;
int ans = 0;
while (p < M) {
ans++;
long long pos = A[p] - p;
pos -= pos % K;
pos += p;
while (p < M && A[p] < pos + K) p++;
}
cout << ans << nl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int T = 1;
while (T--) {
solve();
}
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Special Agent Smart Beaver works in a secret research department of ABBYY. He's been working there for a long time and is satisfied with his job, as it allows him to eat out in the best restaurants and order the most expensive and exotic wood types there.
The content special agent has got an important task: to get the latest research by British scientists on the English Language. These developments are encoded and stored in a large safe. The Beaver's teeth are strong enough, so the authorities assured that upon arriving at the place the beaver won't have any problems with opening the safe.
And he finishes his aspen sprig and leaves for this important task. Of course, the Beaver arrived at the location without any problems, but alas. He can't open the safe with his strong and big teeth. At this point, the Smart Beaver get a call from the headquarters and learns that opening the safe with the teeth is not necessary, as a reliable source has sent the following information: the safe code consists of digits and has no leading zeroes. There also is a special hint, which can be used to open the safe. The hint is string s with the following structure:
* if si = "?", then the digit that goes i-th in the safe code can be anything (between 0 to 9, inclusively);
* if si is a digit (between 0 to 9, inclusively), then it means that there is digit si on position i in code;
* if the string contains letters from "A" to "J", then all positions with the same letters must contain the same digits and the positions with distinct letters must contain distinct digits.
* The length of the safe code coincides with the length of the hint.
For example, hint "?JGJ9" has such matching safe code variants: "51919", "55959", "12329", "93539" and so on, and has wrong variants such as: "56669", "00111", "03539" and "13666".
After receiving such information, the authorities change the plan and ask the special agents to work quietly and gently and not to try to open the safe by mechanical means, and try to find the password using the given hint.
At a special agent school the Smart Beaver was the fastest in his platoon finding codes for such safes, but now he is not in that shape: the years take their toll ... Help him to determine the number of possible variants of the code to the safe, matching the given hint. After receiving this information, and knowing his own speed of entering codes, the Smart Beaver will be able to determine whether he will have time for tonight's show "Beavers are on the trail" on his favorite TV channel, or he should work for a sleepless night...
Input
The first line contains string s β the hint to the safe code. String s consists of the following characters: ?, 0-9, A-J. It is guaranteed that the first character of string s doesn't equal to character 0.
The input limits for scoring 30 points are (subproblem A1):
* 1 β€ |s| β€ 5.
The input limits for scoring 100 points are (subproblems A1+A2):
* 1 β€ |s| β€ 105.
Here |s| means the length of string s.
Output
Print the number of codes that match the given hint.
Examples
Input
AJ
Output
81
Input
1?AA
Output
100
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long n, k, ans = 1, d, res, a[100];
string s;
int main() {
cin >> s;
n = s.length();
for (int i = 0; i < n; i++)
if (s[i] >= 'A' && s[i] <= 'Z' && !a[s[i] - 'A' + 1]) {
k++;
a[s[i] - 'A' + 1] = 1;
}
for (int i = 1; i < n; i++) {
if (s[i] == '?') d++;
}
for (int i = 10; i >= 10 - k + 1; i--) ans *= i;
if (s[0] >= 'A' && s[0] <= 'Z') ans -= ans / 10;
if (s[0] == '?') ans *= 9;
cout << ans;
for (int i = 1; i <= d; i++) cout << 0;
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
Three friends are going to meet each other. Initially, the first friend stays at the position x = a, the second friend stays at the position x = b and the third friend stays at the position x = c on the coordinate axis Ox.
In one minute each friend independently from other friends can change the position x by 1 to the left or by 1 to the right (i.e. set x := x - 1 or x := x + 1) or even don't change it.
Let's introduce the total pairwise distance β the sum of distances between each pair of friends. Let a', b' and c' be the final positions of the first, the second and the third friend, correspondingly. Then the total pairwise distance is |a' - b'| + |a' - c'| + |b' - c'|, where |x| is the absolute value of x.
Friends are interested in the minimum total pairwise distance they can reach if they will move optimally. Each friend will move no more than once. So, more formally, they want to know the minimum total pairwise distance they can reach after one minute.
You have to answer q independent test cases.
Input
The first line of the input contains one integer q (1 β€ q β€ 1000) β the number of test cases.
The next q lines describe test cases. The i-th test case is given as three integers a, b and c (1 β€ a, b, c β€ 10^9) β initial positions of the first, second and third friend correspondingly. The positions of friends can be equal.
Output
For each test case print the answer on it β the minimum total pairwise distance (the minimum sum of distances between each pair of friends) if friends change their positions optimally. Each friend will move no more than once. So, more formally, you have to find the minimum total pairwise distance they can reach after one minute.
Example
Input
8
3 3 4
10 20 30
5 5 5
2 4 3
1 1000000000 1000000000
1 1000000000 999999999
3 2 5
3 2 6
Output
0
36
0
0
1999999994
1999999994
2
4
### Response
```cpp
#include <bits/stdc++.h>
int main() {
int q;
scanf("%d", &q);
int i, j, k, l, m = 0;
long long int a, b, c, min, x, y, z, sum[27];
for (i = 0; i < q; i++) {
scanf("%lld%lld%lld", &a, &b, &c);
m = 0;
for (j = a - 1; j <= a + 1; j++) {
for (k = b - 1; k <= b + 1; k++) {
for (l = c - 1; l <= c + 1; l++) {
x = k - j;
y = l - j;
z = l - k;
if (x < 0) {
x = -x;
}
if (y < 0) {
y = -y;
}
if (z < 0) {
z = -z;
}
sum[m] = x + y + z;
m++;
}
}
}
min = sum[0];
for (j = 1; j < 27; j++) {
if (min > sum[j]) {
min = sum[j];
}
}
printf("%lld\n", min);
}
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Find the number of palindromic numbers among the integers between A and B (inclusive). Here, a palindromic number is a positive integer whose string representation in base 10 (without leading zeros) reads the same forward and backward.
Constraints
* 10000 \leq A \leq B \leq 99999
* All input values are integers.
Input
Input is given from Standard Input in the following format:
A B
Output
Print the number of palindromic numbers among the integers between A and B (inclusive).
Examples
Input
11009 11332
Output
4
Input
31415 92653
Output
612
### Response
```cpp
#include<iostream>
using namespace std;
int a,b,ans=0;
int main(void){
cin>>a>>b;
for(;a<=b;a++)if(a/10000==a%10&&a/1000%10==a%100/10)ans++;
cout<<ans;
return 0;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
The only difference between easy and hard versions is constraints.
You are given a sequence a consisting of n positive integers.
Let's define a three blocks palindrome as the sequence, consisting of at most two distinct elements (let these elements are a and b, a can be equal b) and is as follows: [\underbrace{a, a, ..., a}_{x}, \underbrace{b, b, ..., b}_{y}, \underbrace{a, a, ..., a}_{x}]. There x, y are integers greater than or equal to 0. For example, sequences [], [2], [1, 1], [1, 2, 1], [1, 2, 2, 1] and [1, 1, 2, 1, 1] are three block palindromes but [1, 2, 3, 2, 1], [1, 2, 1, 2, 1] and [1, 2] are not.
Your task is to choose the maximum by length subsequence of a that is a three blocks palindrome.
You have to answer t independent test cases.
Recall that the sequence t is a a subsequence of the sequence s if t can be derived from s by removing zero or more elements without changing the order of the remaining elements. For example, if s=[1, 2, 1, 3, 1, 2, 1], then possible subsequences are: [1, 1, 1, 1], [3] and [1, 2, 1, 3, 1, 2, 1], but not [3, 2, 3] and [1, 1, 1, 1, 2].
Input
The first line of the input contains one integer t (1 β€ t β€ 10^4) β the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (1 β€ n β€ 2 β
10^5) β the length of a. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 β€ a_i β€ 200), where a_i is the i-th element of a. Note that the maximum value of a_i can be up to 200.
It is guaranteed that the sum of n over all test cases does not exceed 2 β
10^5 (β n β€ 2 β
10^5).
Output
For each test case, print the answer β the maximum possible length of some subsequence of a that is a three blocks palindrome.
Example
Input
6
8
1 1 2 2 3 2 1 1
3
1 3 3
4
1 10 10 1
1
26
2
2 1
3
1 1 1
Output
7
2
4
1
1
3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxN = 1e5 + 5;
const int oo = 1e9;
const long long OO = 1e17;
long long MOD = 1e9 + 7;
template <class T>
void input1(vector<T> &x) {
for (int i = (1); i <= int(x.size() - 1); ++i) cin >> x[i];
}
template <class T>
void input2(vector<T> &x) {
for (int i = (1); i <= int(x.size() - 1); ++i) input1(x[i]);
}
template <class T>
void print1(vector<T> &x) {
for (int i = (1); i <= int(x.size() - 1); ++i) cout << x[i] << ' ';
cout << '\n';
}
template <class T>
void print2(vector<T> &x) {
for (int i = (1); i <= int(x.size() - 1); ++i) print1(x[i]);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n, res(1);
cin >> n;
vector<int> a(n + 1);
vector<vector<int> > v(201);
input1(a);
for (int i = (1); i <= int(n); ++i) v[a[i]].push_back(i);
for (int i = (1); i <= int(200); ++i) {
for (int j = (1); j <= int(200); ++j) {
if (v[i].size() == 0 || v[j].size() == 0) continue;
int l = 0, r = v[i].size() - 1;
int x = 0, y = v[j].size() - 1;
while (l < r) {
while (x < v[j].size() && v[j][x] <= v[i][l]) x++;
while (y >= 0 && v[j][y] >= v[i][r]) y--;
if (v[j][x] <= v[i][l] || v[j][y] >= v[i][r]) break;
res = max(res, 2 * l + 2 + y - x + 1);
l++;
r--;
}
}
}
cout << res << '\n';
}
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
You are given three integers x, y and n. Your task is to find the maximum integer k such that 0 β€ k β€ n that k mod x = y, where mod is modulo operation. Many programming languages use percent operator % to implement it.
In other words, with given x, y and n you need to find the maximum possible integer from 0 to n that has the remainder y modulo x.
You have to answer t independent test cases. It is guaranteed that such k exists for each test case.
Input
The first line of the input contains one integer t (1 β€ t β€ 5 β
10^4) β the number of test cases. The next t lines contain test cases.
The only line of the test case contains three integers x, y and n (2 β€ x β€ 10^9;~ 0 β€ y < x;~ y β€ n β€ 10^9).
It can be shown that such k always exists under the given constraints.
Output
For each test case, print the answer β maximum non-negative integer k such that 0 β€ k β€ n and k mod x = y. It is guaranteed that the answer always exists.
Example
Input
7
7 5 12345
5 0 4
10 5 15
17 8 54321
499999993 9 1000000000
10 5 187
2 0 999999999
Output
12339
0
15
54306
999999995
185
999999998
Note
In the first test case of the example, the answer is 12339 = 7 β
1762 + 5 (thus, 12339 mod 7 = 5). It is obvious that there is no greater integer not exceeding 12345 which has the remainder 5 modulo 7.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0);
long long t;
cin >> t;
while (t--) {
long long x, y, n;
cin >> x >> y >> n;
long long a = n % x;
if (a == y)
cout << n << "\n";
else if (a > y) {
cout << n - (a - y) << "\n";
} else {
cout << n - a - (x - y) << "\n";
}
}
return 0;
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
As you know, an undirected connected graph with n nodes and n - 1 edges is called a tree. You are given an integer d and a tree consisting of n nodes. Each node i has a value ai associated with it.
We call a set S of tree nodes valid if following conditions are satisfied:
1. S is non-empty.
2. S is connected. In other words, if nodes u and v are in S, then all nodes lying on the simple path between u and v should also be presented in S.
3. <image>.
Your task is to count the number of valid sets. Since the result can be very large, you must print its remainder modulo 1000000007 (109 + 7).
Input
The first line contains two space-separated integers d (0 β€ d β€ 2000) and n (1 β€ n β€ 2000).
The second line contains n space-separated positive integers a1, a2, ..., an(1 β€ ai β€ 2000).
Then the next n - 1 line each contain pair of integers u and v (1 β€ u, v β€ n) denoting that there is an edge between u and v. It is guaranteed that these edges form a tree.
Output
Print the number of valid sets modulo 1000000007.
Examples
Input
1 4
2 1 3 2
1 2
1 3
3 4
Output
8
Input
0 3
1 2 3
1 2
2 3
Output
3
Input
4 8
7 8 7 5 4 6 4 10
1 6
1 2
5 8
1 3
3 5
6 7
3 4
Output
41
Note
In the first sample, there are exactly 8 valid sets: {1}, {2}, {3}, {4}, {1, 2}, {1, 3}, {3, 4} and {1, 3, 4}. Set {1, 2, 3, 4} is not valid, because the third condition isn't satisfied. Set {1, 4} satisfies the third condition, but conflicts with the second condition.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long n, d, a[2010], f[2010], Answer = 0;
vector<int> v[2010];
const long long Mod = 1e9 + 7;
long long DFS(int x, int p, int Node) {
if (v[x].size() == 1 && v[x][0] == p) return 1;
long long Res = 1;
for (int i = 0; i < v[x].size(); i++) {
int nxt = v[x][i];
if (nxt != p) {
if (a[nxt] < a[Node] || a[nxt] - a[Node] > d ||
(a[nxt] == a[Node] && nxt < Node))
continue;
Res = ((Res % Mod) * (DFS(nxt, x, Node) + 1)) % Mod;
}
}
return Res;
}
int main() {
scanf("%d%d", &d, &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 0; i < n - 1; i++) {
int x, y;
scanf("%d%d", &x, &y);
v[x].push_back(y);
v[y].push_back(x);
}
for (int i = 1; i <= n; i++) {
Answer += DFS(i, -1, i);
Answer %= Mod;
}
printf("%I64d", Answer);
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
Arkady the air traffic controller is now working with n planes in the air. All planes move along a straight coordinate axis with Arkady's station being at point 0 on it. The i-th plane, small enough to be represented by a point, currently has a coordinate of xi and is moving with speed vi. It's guaranteed that xiΒ·vi < 0, i.e., all planes are moving towards the station.
Occasionally, the planes are affected by winds. With a wind of speed vwind (not necessarily positive or integral), the speed of the i-th plane becomes vi + vwind.
According to weather report, the current wind has a steady speed falling inside the range [ - w, w] (inclusive), but the exact value cannot be measured accurately since this value is rather small β smaller than the absolute value of speed of any plane.
Each plane should contact Arkady at the exact moment it passes above his station. And you are to help Arkady count the number of pairs of planes (i, j) (i < j) there are such that there is a possible value of wind speed, under which planes i and j contact Arkady at the same moment. This value needn't be the same across different pairs.
The wind speed is the same for all planes. You may assume that the wind has a steady speed and lasts arbitrarily long.
Input
The first line contains two integers n and w (1 β€ n β€ 100 000, 0 β€ w < 105) β the number of planes and the maximum wind speed.
The i-th of the next n lines contains two integers xi and vi (1 β€ |xi| β€ 105, w + 1 β€ |vi| β€ 105, xiΒ·vi < 0) β the initial position and speed of the i-th plane.
Planes are pairwise distinct, that is, no pair of (i, j) (i < j) exists such that both xi = xj and vi = vj.
Output
Output a single integer β the number of unordered pairs of planes that can contact Arkady at the same moment.
Examples
Input
5 1
-3 2
-3 3
-1 2
1 -3
3 -5
Output
3
Input
6 1
-3 2
-2 2
-1 2
1 -2
2 -2
3 -2
Output
9
Note
In the first example, the following 3 pairs of planes satisfy the requirements:
* (2, 5) passes the station at time 3 / 4 with vwind = 1;
* (3, 4) passes the station at time 2 / 5 with vwind = 1 / 2;
* (3, 5) passes the station at time 4 / 7 with vwind = - 1 / 4.
In the second example, each of the 3 planes with negative coordinates can form a valid pair with each of the other 3, totaling 9 pairs.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, w, tot;
long long ans;
long double l[N], r[N], b[N];
int l2[N], r2[N];
pair<int, int> a[N];
struct tree {
int a[N];
void add(int x, int k) {
for (; x <= tot; x += x & -x) a[x] += k;
}
int ask(int x) {
int res = 0;
for (; x; x -= x & -x) res += a[x];
return res;
}
} T;
bool eq(long double x, long double y) {
return fabs(x - y) < ((long double)0.0000000001);
}
void work(long double &x) { x = floor(x * 1e11) / 1e11; }
int uq(long double *a, int *c) {
for (int i = 1; i <= n; i++) work(a[i]), b[i] = a[i];
sort(b + 1, b + 1 + n);
int tot = unique(b + 1, b + 1 + n) - b - 1;
for (int i = 1; i <= n; i++) c[i] = lower_bound(b + 1, b + 1 + tot, a[i]) - b;
return tot;
}
bool cmp(pair<int, int> x, pair<int, int> y) {
return x.second == y.second ? x.first > y.first : x.second < y.second;
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> w;
for (int i = 1; i <= n; i++) {
int x, v;
cin >> x >> v;
x = -x;
l[i] = (long double)x / ((long double)v - w),
r[i] = (long double)x / ((long double)v + w);
}
tot = uq(l, l2);
uq(r, r2);
for (int i = 1; i <= n; i++) a[i] = make_pair(l2[i], r2[i]);
sort(a + 1, a + 1 + n, cmp);
for (int i = 1; i <= n; i++) {
ans += T.ask(tot) - T.ask(a[i].first - 1);
T.add(a[i].first, 1);
}
cout << ans;
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
You have n devices that you want to use simultaneously.
The i-th device uses ai units of power per second. This usage is continuous. That is, in λ seconds, the device will use λ·ai units of power. The i-th device currently has bi units of power stored. All devices can store an arbitrary amount of power.
You have a single charger that can plug to any single device. The charger will add p units of power per second to a device. This charging is continuous. That is, if you plug in a device for λ seconds, it will gain λ·p units of power. You can switch which device is charging at any arbitrary unit of time (including real numbers), and the time it takes to switch is negligible.
You are wondering, what is the maximum amount of time you can use the devices until one of them hits 0 units of power.
If you can use the devices indefinitely, print -1. Otherwise, print the maximum amount of time before any one device hits 0 power.
Input
The first line contains two integers, n and p (1 β€ n β€ 100 000, 1 β€ p β€ 109) β the number of devices and the power of the charger.
This is followed by n lines which contain two integers each. Line i contains the integers ai and bi (1 β€ ai, bi β€ 100 000) β the power of the device and the amount of power stored in the device in the beginning.
Output
If you can use the devices indefinitely, print -1. Otherwise, print the maximum amount of time before any one device hits 0 power.
Your answer will be considered correct if its absolute or relative error does not exceed 10 - 4.
Namely, let's assume that your answer is a and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
2 1
2 2
2 1000
Output
2.0000000000
Input
1 100
1 1
Output
-1
Input
3 5
4 3
5 2
6 1
Output
0.5000000000
Note
In sample test 1, you can charge the first device for the entire time until it hits zero power. The second device has enough power to last this time without being charged.
In sample test 2, you can use the device indefinitely.
In sample test 3, we can charge the third device for 2 / 5 of a second, then switch to charge the second device for a 1 / 10 of a second.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<pair<double, double> > v;
int n, p;
bool calc(double l) {
double sum = 0;
for (int i = 0; i < n; i++) {
double a = v[i].first, b = v[i].second;
if (a * l - b > 0) sum += (a * l - b) / p;
}
return sum < l || fabs(sum - l) <= 1e-15;
}
int main() {
scanf("%d%d", &n, &p);
double a, b;
for (int i = 0; i < n; i++) {
scanf("%lf%lf", &a, &b);
v.push_back(make_pair(a, b));
}
double l = 0, r = 1e18;
double ans = -1;
for (int it = 0; it <= 800; it++) {
double mid = (l + r) / 2;
if (calc(mid)) {
l = mid;
ans = max(ans, mid);
} else
r = mid;
}
if (ans > 1e17) {
puts("-1");
} else
printf("%.6lf", ans);
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
Nanami is an expert at playing games. This day, Nanami's good friend Hajime invited her to watch a game of baseball. Unwilling as she was, she followed him to the stadium. But Nanami had no interest in the game, so she looked around to see if there was something that might interest her. That's when she saw the digital board at one end of the stadium.
The digital board is n pixels in height and m pixels in width, every pixel is either light or dark. The pixels are described by its coordinate. The j-th pixel of the i-th line is pixel (i, j). The board displays messages by switching a combination of pixels to light, and the rest to dark. Nanami notices that the state of the pixels on the board changes from time to time. At certain times, certain pixels on the board may switch from light to dark, or from dark to light.
Nanami wonders, what is the area of the biggest light block such that a specific pixel is on its side. A light block is a sub-rectangle of the board, in which all pixels are light. Pixel (i, j) belongs to a side of sub-rectangle with (x1, y1) and (x2, y2) as its upper-left and lower-right vertex if and only if it satisfies the logical condition:
((i = x1 or i = x2) and (y1 β€ j β€ y2)) or ((j = y1 or j = y2) and (x1 β€ i β€ x2)).
Nanami has all the history of changing pixels, also she has some questions of the described type, can you answer them?
Input
The first line contains three space-separated integers n, m and q (1 β€ n, m, q β€ 1000) β the height and width of the digital board, and the number of operations.
Then follow n lines, each line containing m space-separated integers. The j-th integer of the i-th line is ai, j β the initial state of pixel (i, j).
* If ai, j = 0, pixel (i, j) is initially dark.
* If ai, j = 1, pixel (i, j) is initially light.
Then follow q lines, each line containing three space-separated integers op, x, and y (1 β€ op β€ 2; 1 β€ x β€ n; 1 β€ y β€ m), describing an operation.
* If op = 1, the pixel at (x, y) changes its state (from light to dark or from dark to light).
* If op = 2, Nanami queries the biggest light block with pixel (x, y) on its side.
Output
For each query, print a single line containing one integer β the answer to Nanami's query.
Examples
Input
3 4 5
0 1 1 0
1 0 0 1
0 1 1 0
2 2 2
2 1 2
1 2 2
1 2 3
2 2 2
Output
0
2
6
Input
3 3 4
1 1 1
1 1 1
1 1 1
2 2 2
1 2 2
2 1 1
2 2 1
Output
6
3
3
Note
Consider the first sample.
The first query specifies pixel (2, 2), which is dark itself, so there are no valid light blocks, thus the answer is 0.
The second query specifies pixel (1, 2). The biggest light block is the block with (1, 2) as its upper-left vertex and (1, 3) as its lower-right vertex.
The last query specifies pixel (2, 2), which became light in the third operation. The biggest light block is the block with (1, 2) as its upper-left vertex and (3, 3) as its lower-right vertex.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
int a[N][N];
int n, m, q;
int __left[N][N], _right[N][N], up[N][N], down[N][N];
void update_up(int i, int j) {
if (a[i][j])
up[i][j] = up[i - 1][j] + 1;
else
up[i][j] = 0;
}
void update_down(int i, int j) {
if (a[i][j])
down[i][j] = down[i + 1][j] + 1;
else
down[i][j] = 0;
}
void update_left(int i, int j) {
if (a[i][j])
__left[i][j] = __left[i][j - 1] + 1;
else
__left[i][j] = 0;
}
void update_right(int i, int j) {
if (a[i][j])
_right[i][j] = _right[i][j + 1] + 1;
else
_right[i][j] = 0;
}
void input() {
scanf("%d %d %d", &n, &m, &q);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) scanf("%d", &a[i][j]);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
update_left(i, j);
update_up(i, j);
}
for (int i = n; i >= 1; i--)
for (int j = m; j >= 1; j--) {
update_down(i, j);
update_right(i, j);
}
}
void update(int x, int y) {
a[x][y] ^= 1;
for (int i = x; i <= n; i++) update_up(i, y);
for (int col = y; col <= m; col++) update_left(x, col);
for (int row = x; row >= 1; row--) update_down(row, y);
for (int col = m; col >= 1; col--) update_right(x, col);
}
void maximize(int &u, int v) { u = max(u, v); }
void minimize(int &u, int v) { u = min(u, v); }
int cal(int *b, int pos, int len) {
int l = pos, r = pos;
int top = b[pos];
int ans = 0;
while (true) {
maximize(ans, (r - l + 1) * top);
if (l == 1 && r == len) return ans;
if (l == 1) {
r++;
minimize(top, b[r]);
} else if (r == len) {
l--;
minimize(top, b[l]);
} else {
if (b[l - 1] >= b[r + 1]) {
l--;
minimize(top, b[l]);
} else {
r++;
minimize(top, b[r]);
}
}
}
}
int solve(int x, int y) {
int b[N];
int ans = 0;
for (int i = 1; i <= m; i++) b[i] = up[x][i];
maximize(ans, cal(b, y, m));
for (int i = 1; i <= m; i++) b[i] = down[x][i];
maximize(ans, cal(b, y, m));
for (int i = 1; i <= n; i++) b[i] = __left[i][y];
maximize(ans, cal(b, x, n));
for (int i = 1; i <= n; i++) b[i] = _right[i][y];
maximize(ans, cal(b, x, n));
return ans;
}
int main() {
input();
while (q--) {
int type, x, y;
scanf("%d %d %d", &type, &x, &y);
if (type == 1) {
update(x, y);
} else {
printf("%d\n", solve(x, y));
}
}
}
``` |
### Prompt
Generate a cpp solution to the following problem:
problem
During this time of winter in Japan, hot days continue in Australia in the Southern Hemisphere. IOI, who lives in Australia, decided to plan what clothes to wear based on the weather forecast for a certain D day. The maximum temperature on day i (1 β€ i β€ D) is predicted to be Ti degrees.
IOI has N kinds of clothes, which are numbered from 1 to N. Clothes j (1 β€ j β€ N) are suitable for wearing on days when the maximum temperature is above Aj and below Bj. In addition, each clothes has an integer called "flashiness", and the flashiness of clothes j is Cj.
For each of the D days, IOI chooses to wear one of the clothes suitable for wearing when the maximum temperature follows the weather forecast. You may choose the same clothes as many times as you like, or you may choose clothes that are never chosen in D days.
IOI, who wanted to avoid wearing similar clothes in succession, decided to maximize the total absolute value of the difference in the flashiness of the clothes worn on consecutive days. That is, assuming that the clothes xi are selected on the i-day, we want to maximize the values ββ| Cx1 --Cx2 | + | Cx2 --Cx3 | +β¦ + | CxD-1 --CxD |. Create a program to find this maximum value.
input
The input consists of 1 + D + N lines.
On the first line, two integers D and N (2 β€ D β€ 200, 1 β€ N β€ 200) are written with a blank as a delimiter. D is the number of days to plan clothes and N is the number of clothes types IOI has.
One integer Ti (0 β€ Ti β€ 60) is written in the i-th line (1 β€ i β€ D) of the following D lines. This means that the maximum temperature on day i is forecast to be Ti degrees.
In the jth line (1 β€ j β€ N) of the following N lines, three integers Aj, Bj, Cj (0 β€ Aj β€ Bj β€ 60, 0 β€ Cj β€ 100) are written. These indicate that clothing j is suitable for wearing on days when the maximum temperature is above Aj and below Bj, and the flashiness is Cj.
It is guaranteed that there will be at least one piece of clothing suitable for wearing when the maximum temperature follows the weather forecast for every D day.
output
Output the total absolute value of the difference in the flashiness of clothes worn on consecutive days, that is, the maximum value of the values ββ| Cx1 --Cx2 | + | Cx2 --Cx3 | +β¦ + | CxD-1 --CxD | in one line. ..
Input / output example
Input example 1
3 4
31
27
35
20 25 30
23 29 90
21 35 60
28 33 40
Output example 1
80
In the input / output example 1, the candidates for clothes on the first day are clothes 3 and 4, the candidates for clothes on the second day are clothes 2 and clothes 3, and the candidates for clothes on the third day are only clothes 3. is there. Choose clothes 4 on the first day, clothes 2 on the second day, and clothes 3 on the third day. That is, x1 = 4, x2 = 2, x3 = 3. At this time, the absolute value of the difference in the flashiness of the clothes on the first day and the second day is | 40 --90 | = 50, and the absolute value of the difference in the flashiness of the clothes on the second and third days is | 90-60 | = 30. The total is 80, which is the maximum value.
Input example 2
5 2
26
28
32
29
34
30 35 0
25 30 100
Output example 2
300
In Example 2 of input / output, clothes 2 on the first day, clothes 2 on the second day, clothes 1 on the third day, clothes 2 on the fourth day, and clothes 1 on the fifth day. You have to choose. At this time, the required value is | 100 --100 | + | 100 --0 | + | 0 --100 | + | 100 --0 | = 300.
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
3 4
31
27
35
20 25 30
23 29 90
21 35 60
28 33 40
Output
80
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int ze(int a){
if(a<0)return -a;
return a;
}
int main(){
int a,b;
cin>>a>>b;
vector<int>c(a);
for(int d=0;d<a;d++)cin>>c[d];
vector<vector<int>>e(b,vector<int>(3));
for(int f=0;f<b;f++)cin>>e[f][0]>>e[f][1]>>e[f][2];
vector<vector<int>>dp(a+1,vector<int>(b));
for(int h=1;h<a;h++){
for(int i=0;i<b;i++){
if(c[h]>=e[i][0]&&c[h]<=e[i][1]){
int s=0;
for(int j=0;j<b;j++){
if(c[h-1]>=e[j][0]&&c[h-1]<=e[j][1])
s=max(s,dp[h][j]+ze(e[i][2]-e[j][2]));
}
dp[h+1][i]=s;
}
}
}
int x=0;
for(int y:dp[a]){
if(x<y)x=y;
}
cout<<x<<endl;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
Note the unusual memory limit for the problem.
People working in MDCS (Microsoft Development Center Serbia) like partying. They usually go to night clubs on Friday and Saturday.
There are N people working in MDCS and there are N clubs in the city. Unfortunately, if there is more than one Microsoft employee in night club, level of coolness goes infinitely high and party is over, so club owners will never let more than one Microsoft employee enter their club in the same week (just to be sure).
You are organizing night life for Microsoft employees and you have statistics about how much every employee likes Friday and Saturday parties for all clubs.
You need to match people with clubs maximizing overall sum of their happiness (they are happy as much as they like the club), while half of people should go clubbing on Friday and the other half on Saturday.
Input
The first line contains integer N β number of employees in MDCS.
Then an N Γ N matrix follows, where element in i-th row and j-th column is an integer number that represents how much i-th person likes j-th clubβs Friday party.
Then another N Γ N matrix follows, where element in i-th row and j-th column is an integer number that represents how much i-th person likes j-th clubβs Saturday party.
* 2 β€ N β€ 20
* N is even
* 0 β€ level of likeness β€ 106
* All values are integers
Output
Output should contain a single integer β maximum sum of happiness possible.
Examples
Input
4
1 2 3 4
2 3 4 1
3 4 1 2
4 1 2 3
5 8 7 1
6 9 81 3
55 78 1 6
1 1 1 1
Output
167
Note
Here is how we matched people with clubs:
Friday: 1st person with 4th club (4 happiness) and 4th person with 1st club (4 happiness).
Saturday: 2nd person with 3rd club (81 happiness) and 3rd person with 2nd club (78 happiness).
4+4+81+78 = 167
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 20, M = 30, inf = 1000000000, L = 20000;
int nx, ny, cnt;
int link[M], lx[M], ly[M], slack[M];
int visx[M], visy[M], w[M][M];
int DFS(int x) {
visx[x] = 1;
for (int y = 1; y <= ny; y++) {
if (visy[y]) continue;
int t = lx[x] + ly[y] - w[x][y];
if (t == 0) {
visy[y] = 1;
if (link[y] == -1 || DFS(link[y])) {
link[y] = x;
return 1;
}
} else if (slack[y] > t)
slack[y] = t;
}
return 0;
}
int KM() {
int i, j;
memset(link, -1, sizeof(link));
memset(ly, 0, sizeof(ly));
for (i = 1; i <= nx; i++)
for (j = 1, lx[i] = -inf; j <= ny; j++)
if (w[i][j] > lx[i]) lx[i] = w[i][j];
for (int x = 1; x <= nx; x++) {
for (i = 1; i <= ny; i++) slack[i] = inf;
while (1) {
memset(visx, 0, sizeof(visx));
memset(visy, 0, sizeof(visy));
if (DFS(x)) break;
int d = inf;
for (i = 1; i <= ny; i++)
if (!visy[i] && d > slack[i]) d = slack[i];
for (i = 1; i <= nx; i++)
if (visx[i]) lx[i] -= d;
for (i = 1; i <= ny; i++)
if (visy[i])
ly[i] += d;
else
slack[i] -= d;
}
}
int res = 0;
for (i = 1; i <= ny; i++)
if (link[i] > -1) res += w[link[i]][i];
return res;
}
int ai[N + 10][N + 10], n, bi[N + 10][N + 10], ans, flag[N + 10];
int Work() {
int i, j;
for (i = 1; i <= n; i++) {
if (flag[i])
for (j = 1; j <= n; j++) w[i][j] = ai[i][j];
else
for (j = 1; j <= n; j++) w[i][j] = bi[i][j];
}
return KM();
}
int main() {
int i, j, x, y, tmp, ans2 = 0;
srand(5215251);
scanf("%d", &n);
nx = ny = n;
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++) scanf("%d", &ai[i][j]);
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++) scanf("%d", &bi[i][j]);
for (i = 1; i <= n / 2; i++) flag[i] = 1;
cnt = L;
while (cnt--) {
x = rand() % (n / 2), y = rand() % (n / 2);
for (i = 1; i <= n; i++) {
if (flag[i]) {
if (x == 0) break;
x--;
}
}
x = i;
for (i = 1; i <= n; i++) {
if (!flag[i]) {
if (y == 0) break;
y--;
}
}
y = i;
flag[x] ^= 1, flag[y] ^= 1;
tmp = Work();
if (tmp > ans)
ans = tmp;
else {
if (rand() % L > (L - cnt + 100) / 3)
flag[x] ^= 1, flag[y] ^= 1;
else
ans = tmp;
}
ans2 = max(ans2, ans);
}
printf("%d\n", ans2);
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
Polycarpus has an array, consisting of n integers a1, a2, ..., an. Polycarpus likes it when numbers in an array match. That's why he wants the array to have as many equal numbers as possible. For that Polycarpus performs the following operation multiple times:
* he chooses two elements of the array ai, aj (i β j);
* he simultaneously increases number ai by 1 and decreases number aj by 1, that is, executes ai = ai + 1 and aj = aj - 1.
The given operation changes exactly two distinct array elements. Polycarpus can apply the described operation an infinite number of times.
Now he wants to know what maximum number of equal array elements he can get if he performs an arbitrary number of such operation. Help Polycarpus.
Input
The first line contains integer n (1 β€ n β€ 105) β the array size. The second line contains space-separated integers a1, a2, ..., an (|ai| β€ 104) β the original array.
Output
Print a single integer β the maximum number of equal array elements he can get if he performs an arbitrary number of the given operation.
Examples
Input
2
2 1
Output
1
Input
3
1 4 1
Output
3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
int k = 0, sum = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> k;
sum += k;
}
if (sum % n == 0) {
cout << n;
} else {
cout << n - 1;
}
return 0;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
Gerald got a very curious hexagon for his birthday. The boy found out that all the angles of the hexagon are equal to <image>. Then he measured the length of its sides, and found that each of them is equal to an integer number of centimeters. There the properties of the hexagon ended and Gerald decided to draw on it.
He painted a few lines, parallel to the sides of the hexagon. The lines split the hexagon into regular triangles with sides of 1 centimeter. Now Gerald wonders how many triangles he has got. But there were so many of them that Gerald lost the track of his counting. Help the boy count the triangles.
Input
The first and the single line of the input contains 6 space-separated integers a1, a2, a3, a4, a5 and a6 (1 β€ ai β€ 1000) β the lengths of the sides of the hexagons in centimeters in the clockwise order. It is guaranteed that the hexagon with the indicated properties and the exactly such sides exists.
Output
Print a single integer β the number of triangles with the sides of one 1 centimeter, into which the hexagon is split.
Examples
Input
1 1 1 1 1 1
Output
6
Input
1 2 1 2 1 2
Output
13
Note
This is what Gerald's hexagon looks like in the first sample:
<image>
And that's what it looks like in the second sample:
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, e, f;
cin >> a >> b >> c >> d >> e >> f;
cout << (a + b + c) * (a + b + c) - a * a - c * c - e * e;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
As Sherlock Holmes was investigating a crime, he identified n suspects. He knows for sure that exactly one of them committed the crime. To find out which one did it, the detective lines up the suspects and numbered them from 1 to n. After that, he asked each one: "Which one committed the crime?". Suspect number i answered either "The crime was committed by suspect number ai", or "Suspect number ai didn't commit the crime". Also, the suspect could say so about himself (ai = i).
Sherlock Holmes understood for sure that exactly m answers were the truth and all other answers were a lie. Now help him understand this: which suspect lied and which one told the truth?
Input
The first line contains two integers n and m (1 β€ n β€ 105, 0 β€ m β€ n) β the total number of suspects and the number of suspects who told the truth. Next n lines contain the suspects' answers. The i-th line contains either "+ai" (without the quotes), if the suspect number i says that the crime was committed by suspect number ai, or "-ai" (without the quotes), if the suspect number i says that the suspect number ai didn't commit the crime (ai is an integer, 1 β€ ai β€ n).
It is guaranteed that at least one suspect exists, such that if he committed the crime, then exactly m people told the truth.
Output
Print n lines. Line number i should contain "Truth" if suspect number i has told the truth for sure. Print "Lie" if the suspect number i lied for sure and print "Not defined" if he could lie and could tell the truth, too, depending on who committed the crime.
Examples
Input
1 1
+1
Output
Truth
Input
3 2
-1
-2
-3
Output
Not defined
Not defined
Not defined
Input
4 1
+2
-3
+4
-1
Output
Lie
Not defined
Lie
Not defined
Note
The first sample has the single person and he confesses to the crime, and Sherlock Holmes knows that one person is telling the truth. That means that this person is telling the truth.
In the second sample there are three suspects and each one denies his guilt. Sherlock Holmes knows that only two of them are telling the truth. Any one of them can be the criminal, so we don't know for any of them, whether this person is telling the truth or not.
In the third sample the second and the fourth suspect defend the first and the third one. But only one is telling the truth, thus, the first or the third one is the criminal. Both of them can be criminals, so the second and the fourth one can either be lying or telling the truth. The first and the third one are lying for sure as they are blaming the second and the fourth one.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 0, 1, -1, 1, -1, 1, -1};
int dy[] = {1, -1, 0, 0, -1, 1, 1, -1};
long long gcd(long long a, long long b) { return !b ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return (a / gcd(a, b)) * b; }
void PLAY() {
cout << fixed << setprecision(10);
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
int a[100005], cnt[100005];
int main() {
PLAY();
int n, m;
cin >> n >> m;
int neg = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] > 0)
cnt[a[i]]++;
else
cnt[-a[i]]--, neg++;
}
int res = 0;
for (int i = 1; i <= n; i++) res += cnt[i] == m - neg;
for (int i = 0; i < n; i++) {
if (cnt[abs(a[i])] + neg != m)
cout << (a[i] > 0 ? "Lie" : "Truth") << endl;
else if (res == 1)
cout << (a[i] > 0 ? "Truth" : "Lie") << endl;
else
cout << "Not defined" << endl;
}
return 0;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
Polycarp starts his own business. Tomorrow will be the first working day of his car repair shop. For now the car repair shop is very small and only one car can be repaired at a given time.
Polycarp is good at marketing, so he has already collected n requests from clients. The requests are numbered from 1 to n in order they came.
The i-th request is characterized by two values: si β the day when a client wants to start the repair of his car, di β duration (in days) to repair the car. The days are enumerated from 1, the first day is tomorrow, the second day is the day after tomorrow and so on.
Polycarp is making schedule by processing requests in the order from the first to the n-th request. He schedules the i-th request as follows:
* If the car repair shop is idle for di days starting from si (si, si + 1, ..., si + di - 1), then these days are used to repair a car of the i-th client.
* Otherwise, Polycarp finds the first day x (from 1 and further) that there are di subsequent days when no repair is scheduled starting from x. In other words he chooses the smallest positive x that all days x, x + 1, ..., x + di - 1 are not scheduled for repair of any car. So, the car of the i-th client will be repaired in the range [x, x + di - 1]. It is possible that the day x when repair is scheduled to start will be less than si.
Given n requests, you are asked to help Polycarp schedule all of them according to the rules above.
Input
The first line contains integer n (1 β€ n β€ 200) β the number of requests from clients.
The following n lines contain requests, one request per line. The i-th request is given as the pair of integers si, di (1 β€ si β€ 109, 1 β€ di β€ 5Β·106), where si is the preferred time to start repairing the i-th car, di is the number of days to repair the i-th car.
The requests should be processed in the order they are given in the input.
Output
Print n lines. The i-th line should contain two integers β the start day to repair the i-th car and the finish day to repair the i-th car.
Examples
Input
3
9 2
7 3
2 4
Output
9 10
1 3
4 7
Input
4
1000000000 1000000
1000000000 1000000
100000000 1000000
1000000000 1000000
Output
1000000000 1000999999
1 1000000
100000000 100999999
1000001 2000000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct period {
long long start, len;
} ps[1000];
int np;
int main() {
long long i, first, fit, n, a, b, firstp;
cin >> n;
np = 1;
ps[1].start = 1;
ps[1].len = 210000000000000LL;
for (int task = 1; task <= n; task++) {
cin >> a >> b;
firstp = 0;
fit = 0;
first = 210000000000000LL;
for (i = 1; i <= np; i++) {
if (first >= ps[i].start && ps[i].len >= b) {
first = ps[i].start;
firstp = i;
}
if (ps[i].start <= a && ps[i].start + ps[i].len >= a + b) fit = i;
}
if (fit) {
if (ps[fit].start == a) {
ps[fit].start += b;
ps[fit].len -= b;
} else if (ps[fit].len + ps[fit].start == a + b) {
ps[fit].len -= b;
} else {
if (a + b < ps[fit].len + ps[fit].start) {
np++;
ps[np].start = a + b;
ps[np].len = ps[fit].len + ps[fit].start - a - b;
}
ps[fit].len = a - ps[fit].start;
}
printf("%I64d %I64d\n", a, a + b - 1);
} else {
printf("%I64d %I64d\n", ps[firstp].start, ps[firstp].start + b - 1);
ps[firstp].start += b;
ps[firstp].len -= b;
}
}
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
The Smart Beaver has recently designed and built an innovative nanotechnologic all-purpose beaver mass shaving machine, "Beavershave 5000". Beavershave 5000 can shave beavers by families! How does it work? Very easily!
There are n beavers, each of them has a unique id from 1 to n. Consider a permutation a1, a2, ..., an of n these beavers. Beavershave 5000 needs one session to shave beavers with ids from x to y (inclusive) if and only if there are such indices i1 < i2 < ... < ik, that ai1 = x, ai2 = x + 1, ..., aik - 1 = y - 1, aik = y. And that is really convenient. For example, it needs one session to shave a permutation of beavers 1, 2, 3, ..., n.
If we can't shave beavers from x to y in one session, then we can split these beavers into groups [x, p1], [p1 + 1, p2], ..., [pm + 1, y] (x β€ p1 < p2 < ... < pm < y), in such a way that the machine can shave beavers in each group in one session. But then Beavershave 5000 needs m + 1 working sessions to shave beavers from x to y.
All beavers are restless and they keep trying to swap. So if we consider the problem more formally, we can consider queries of two types:
* what is the minimum number of sessions that Beavershave 5000 needs to shave beavers with ids from x to y, inclusive?
* two beavers on positions x and y (the beavers ax and ay) swapped.
You can assume that any beaver can be shaved any number of times.
Input
The first line contains integer n β the total number of beavers, 2 β€ n. The second line contains n space-separated integers β the initial beaver permutation.
The third line contains integer q β the number of queries, 1 β€ q β€ 105. The next q lines contain the queries. Each query i looks as pi xi yi, where pi is the query type (1 is to shave beavers from xi to yi, inclusive, 2 is to swap beavers on positions xi and yi). All queries meet the condition: 1 β€ xi < yi β€ n.
* to get 30 points, you need to solve the problem with constraints: n β€ 100 (subproblem B1);
* to get 100 points, you need to solve the problem with constraints: n β€ 3Β·105 (subproblems B1+B2).
Note that the number of queries q is limited 1 β€ q β€ 105 in both subproblem B1 and subproblem B2.
Output
For each query with pi = 1, print the minimum number of Beavershave 5000 sessions.
Examples
Input
5
1 3 4 2 5
6
1 1 5
1 3 4
2 2 3
1 1 5
2 1 5
1 1 5
Output
2
1
3
5
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 110;
const int INF = 1 << 28;
const double EPS = 1e-9;
const double PI = 3.14159265358979;
struct BIT {
int n;
long long bit[MAX_N];
void init(int n_) {
n = n_;
memset(bit, 0, sizeof(bit));
}
long long sum(int k) {
long long s = 0;
while (k > 0) {
s += bit[k];
k -= k & -k;
}
return s;
}
long long sum(int a, int b) { return sum(b) - sum(a); }
void add(int k, long long v) {
k++;
while (k <= n) {
bit[k] += v;
k += k & -k;
}
}
};
int n, Q;
int a[MAX_N];
bool used[MAX_N];
void solve() {
for (int q = (0); q < (Q); q++) {
int p, x, y;
cin >> p >> x >> y;
x--, y--;
if (p == 1) {
memset(used, false, sizeof(used));
int r = 0;
for (int i = (0); i < (n); i++) {
if (x <= a[i] && a[i] <= y) {
if (a[i] == x) {
used[x] = true;
r++;
} else {
if (!used[a[i] - 1]) {
r++;
}
used[a[i]] = true;
}
}
}
cout << r << endl;
} else {
swap(a[x], a[y]);
}
}
}
int main() {
cin >> n;
for (int i = (0); i < (n); i++) {
cin >> a[i];
a[i]--;
}
cin >> Q;
solve();
return 0;
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
The famous sculptor Cicasso is a Reberlandian spy!
These is breaking news in Berlandian papers today. And now the sculptor is hiding. This time you give the shelter to the maestro. You have a protected bunker and you provide it to your friend. You set the security system in such way that only you can open the bunker. To open it one should solve the problem which is hard for others but is simple for you.
Every day the bunker generates a codeword s. Every time someone wants to enter the bunker, integer n appears on the screen. As the answer one should enter another integer β the residue modulo 109 + 7 of the number of strings of length n that consist only of lowercase English letters and contain the string s as the subsequence.
The subsequence of string a is a string b that can be derived from the string a by removing some symbols from it (maybe none or all of them). In particular any string is the subsequence of itself. For example, the string "cfo" is the subsequence of the string "codeforces".
You haven't implemented the algorithm that calculates the correct answers yet and you should do that ASAP.
Input
The first line contains integer m (1 β€ m β€ 105) β the number of the events in the test case.
The second line contains nonempty string s β the string generated by the bunker for the current day.
The next m lines contain the description of the events. The description starts from integer t β the type of the event.
If t = 1 consider a new day has come and now a new string s is used. In that case the same line contains a new value of the string s.
If t = 2 integer n is given (1 β€ n β€ 105). This event means that it's needed to find the answer for the current string s and the value n.
The sum of lengths of all generated strings doesn't exceed 105. All of the given strings consist only of lowercase English letters.
Output
For each query of the type 2 print the answer modulo 109 + 7 on the separate line.
Example
Input
3
a
2 2
1 bc
2 5
Output
51
162626
Note
In the first event words of the form "a?" and "?a" are counted, where ? is an arbitrary symbol. There are 26 words of each of these types, but the word "aa" satisfies both patterns, so the answer is 51.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int M = 1e9 + 7;
int power(int a, int p) {
if (p == 0) return 1;
int ans = power(a, p / 2);
ans = (1LL * ans * ans) % M;
if (p % 2) ans = (1LL * ans * a) % M;
return ans;
}
const int N = 1e5 + 7;
int f[N], p26[N];
int fac[N], invfac[N];
void pre() {
fac[0] = p26[0] = 1;
for (int i = 1; i < N; i++) {
fac[i] = (1LL * fac[i - 1] * i) % M;
p26[i] = (1LL * p26[i - 1] * 26) % M;
}
invfac[N - 1] = power(fac[N - 1], M - 2);
for (int i = N - 2; i >= 0; i--)
invfac[i] = (1LL * invfac[i + 1] * (i + 1)) % M;
int b = (25LL * power(26, M - 2)) % M;
int pb = 1;
for (int i = 0; i < N; i++) {
f[i] = (1LL * pb * invfac[i]) % M;
pb = (1LL * pb * b) % M;
}
}
vector<int> sol[N];
void calc(int k) {
sol[k].resize(N);
int sum = 0;
for (int i = 0; k + i < N; i++) {
sum = (sum + 1LL * fac[k + i] * f[i]) % M;
sol[k][i] = sum;
}
}
int solve(int n, int k) {
if (n < 0) return 0;
if (sol[k].empty()) calc(k);
int ans = sol[k][n];
ans = (1LL * ans * invfac[k]) % M;
ans = (1LL * ans * p26[n]) % M;
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
pre();
int t;
cin >> t;
string s;
cin >> s;
int k = s.size() - 1;
while (t--) {
int t;
cin >> t;
if (t == 1) {
cin >> s;
k = s.size() - 1;
} else {
int n;
cin >> n;
cout << solve(n - k - 1, k) << "\n";
}
}
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
The term of this problem is the same as the previous one, the only exception β increased restrictions.
Input
The first line contains two positive integers n and k (1 β€ n β€ 100 000, 1 β€ k β€ 109) β the number of ingredients and the number of grams of the magic powder.
The second line contains the sequence a1, a2, ..., an (1 β€ ai β€ 109), where the i-th number is equal to the number of grams of the i-th ingredient, needed to bake one cookie.
The third line contains the sequence b1, b2, ..., bn (1 β€ bi β€ 109), where the i-th number is equal to the number of grams of the i-th ingredient, which Apollinaria has.
Output
Print the maximum number of cookies, which Apollinaria will be able to bake using the ingredients that she has and the magic powder.
Examples
Input
1 1000000000
1
1000000000
Output
2000000000
Input
10 1
1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000
1 1 1 1 1 1 1 1 1 1
Output
0
Input
3 1
2 1 4
11 3 16
Output
4
Input
4 3
4 3 5 6
11 12 14 20
Output
3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const double PI = 3.141592653589793238463;
long long n, k;
long long a[(int)1e5 + 5], b[(int)1e5 + 5];
bool comp(pair<int, int> p1, pair<int, int> p2) {
return p1.first >= p2.first && p1.second > p2.second;
}
bool fuck(long long mid) {
long long nn = k;
for (int i = 0; i < n; i++) {
long long t = mid * (long long)a[i];
if (t > b[i]) nn -= (t - b[i]);
if (nn < 0) return false;
}
if (nn < 0)
return false;
else
return true;
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> b[i];
long long l = 1, r = 2e9 + 1;
long long ans = 0;
while (l <= r) {
long long mid = (l + r) / 2;
if (fuck(mid) == true) {
l = mid + 1;
ans = mid;
} else
r = mid - 1;
}
cout << ans << '\n';
return 0;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
Chloe, the same as Vladik, is a competitive programmer. She didn't have any problems to get to the olympiad like Vladik, but she was confused by the task proposed on the olympiad.
Let's consider the following algorithm of generating a sequence of integers. Initially we have a sequence consisting of a single element equal to 1. Then we perform (n - 1) steps. On each step we take the sequence we've got on the previous step, append it to the end of itself and insert in the middle the minimum positive integer we haven't used before. For example, we get the sequence [1, 2, 1] after the first step, the sequence [1, 2, 1, 3, 1, 2, 1] after the second step.
The task is to find the value of the element with index k (the elements are numbered from 1) in the obtained sequence, i. e. after (n - 1) steps.
Please help Chloe to solve the problem!
Input
The only line contains two integers n and k (1 β€ n β€ 50, 1 β€ k β€ 2n - 1).
Output
Print single integer β the integer at the k-th position in the obtained sequence.
Examples
Input
3 2
Output
2
Input
4 8
Output
4
Note
In the first sample the obtained sequence is [1, 2, 1, 3, 1, 2, 1]. The number on the second position is 2.
In the second sample the obtained sequence is [1, 2, 1, 3, 1, 2, 1, 4, 1, 2, 1, 3, 1, 2, 1]. The number on the eighth position is 4.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
unsigned long long pow2[55];
int main() {
unsigned long long n, i, mid;
cin >> n;
pow2[0] = 1;
pow2[1] = 2;
for (i = 2; i <= n; i++) pow2[i] = pow2[i - 1] * 2;
unsigned long long p;
cin >> p;
while (1) {
mid = pow2[n - 1];
if (p == mid) {
cout << n;
break;
} else if (p > mid) {
p = p - mid;
} else {
p = p;
}
n--;
}
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
You are given a graph with 3 β
n vertices and m edges. You are to find a matching of n edges, or an independent set of n vertices.
A set of edges is called a matching if no two edges share an endpoint.
A set of vertices is called an independent set if no two vertices are connected with an edge.
Input
The first line contains a single integer T β₯ 1 β the number of graphs you need to process. The description of T graphs follows.
The first line of description of a single graph contains two integers n and m, where 3 β
n is the number of vertices, and m is the number of edges in the graph (1 β€ n β€ 10^{5}, 0 β€ m β€ 5 β
10^{5}).
Each of the next m lines contains two integers v_i and u_i (1 β€ v_i, u_i β€ 3 β
n), meaning that there is an edge between vertices v_i and u_i.
It is guaranteed that there are no self-loops and no multiple edges in the graph.
It is guaranteed that the sum of all n over all graphs in a single test does not exceed 10^{5}, and the sum of all m over all graphs in a single test does not exceed 5 β
10^{5}.
Output
Print your answer for each of the T graphs. Output your answer for a single graph in the following format.
If you found a matching of size n, on the first line print "Matching" (without quotes), and on the second line print n integers β the indices of the edges in the matching. The edges are numbered from 1 to m in the input order.
If you found an independent set of size n, on the first line print "IndSet" (without quotes), and on the second line print n integers β the indices of the vertices in the independent set.
If there is no matching and no independent set of the specified size, print "Impossible" (without quotes).
You can print edges and vertices in any order.
If there are several solutions, print any. In particular, if there are both a matching of size n, and an independent set of size n, then you should print exactly one of such matchings or exactly one of such independent sets.
Example
Input
4
1 2
1 3
1 2
1 2
1 3
1 2
2 5
1 2
3 1
1 4
5 1
1 6
2 15
1 2
1 3
1 4
1 5
1 6
2 3
2 4
2 5
2 6
3 4
3 5
3 6
4 5
4 6
5 6
Output
Matching
2
IndSet
1
IndSet
2 4
Matching
1 15
Note
The first two graphs are same, and there are both a matching of size 1 and an independent set of size 1. Any of these matchings and independent sets is a correct answer.
The third graph does not have a matching of size 2, however, there is an independent set of size 2. Moreover, there is an independent set of size 5: 2 3 4 5 6. However such answer is not correct, because you are asked to find an independent set (or matching) of size exactly n.
The fourth graph does not have an independent set of size 2, but there is a matching of size 2.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int nmax = 300005;
vector<int> v[nmax];
int cup[nmax], edg[2 * nmax];
int i, j, n, m, t, rel, a, b, nr;
int main() {
ios_base::sync_with_stdio(false);
cin >> t;
for (int cnt = 1; cnt <= t; cnt++) {
cin >> n >> m;
nr = 0;
for (i = 1; i <= 3 * n; i++) {
cup[i] = 0;
}
for (i = 1; i <= m; i++) {
cin >> a >> b;
if (cup[a] + cup[b] == 0) {
cup[a] = 1;
cup[b] = 1;
edg[++nr] = i;
}
}
if (nr >= n) {
cout << "Matching\n";
for (i = 1; i <= n; i++) cout << edg[i] << ' ';
cout << '\n';
} else {
int cate = 0;
cout << "IndSet\n";
for (i = 1; i <= 3 * n; i++)
if ((!cup[i]) && cate < n) {
cout << i << ' ';
cate++;
}
cout << '\n';
}
}
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
An array of positive integers a1, a2, ..., an is given. Let us consider its arbitrary subarray al, al + 1..., ar, where 1 β€ l β€ r β€ n. For every positive integer s denote by Ks the number of occurrences of s into the subarray. We call the power of the subarray the sum of products KsΒ·KsΒ·s for every positive integer s. The sum contains only finite number of nonzero summands as the number of different values in the array is indeed finite.
You should calculate the power of t given subarrays.
Input
First line contains two integers n and t (1 β€ n, t β€ 200000) β the array length and the number of queries correspondingly.
Second line contains n positive integers ai (1 β€ ai β€ 106) β the elements of the array.
Next t lines contain two positive integers l, r (1 β€ l β€ r β€ n) each β the indices of the left and the right ends of the corresponding subarray.
Output
Output t lines, the i-th line of the output should contain single positive integer β the power of the i-th query subarray.
Please, do not use %lld specificator to read or write 64-bit integers in C++. It is preferred to use cout stream (also you may use %I64d).
Examples
Input
3 2
1 2 1
1 2
1 3
Output
3
6
Input
8 3
1 1 2 2 1 3 1 1
2 7
1 6
2 7
Output
20
20
20
Note
Consider the following array (see the second sample) and its [2, 7] subarray (elements of the subarray are colored):
<image> Then K1 = 3, K2 = 2, K3 = 1, so the power is equal to 32Β·1 + 22Β·2 + 12Β·3 = 20.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int a[N], bl[N];
struct Query {
int l, r, id;
} q[N];
int l = 1, r = 0, cnt[N * 10];
long long now = 0;
long long Ans[N];
void add(int x) {
now -= 1ll * cnt[a[x]] * cnt[a[x]] * a[x];
cnt[a[x]]++;
now += 1ll * cnt[a[x]] * cnt[a[x]] * a[x];
}
void del(int x) {
now -= 1ll * cnt[a[x]] * cnt[a[x]] * a[x];
cnt[a[x]]--;
now += 1ll * cnt[a[x]] * cnt[a[x]] * a[x];
}
bool cmp(Query a, Query b) {
return (bl[a.l] ^ bl[b.l]) ? bl[a.l] < bl[b.l]
: ((bl[a.l] & 1) ? a.r < b.r : a.r > b.r);
}
int main() {
int n, t;
scanf("%d%d", &n, &t);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
int unt = sqrt(n);
for (int i = 1; i <= n; i++) bl[i] = (i - 1) / unt + 1;
for (int i = 1; i <= t; i++) {
scanf("%d%d", &q[i].l, &q[i].r);
q[i].id = i;
}
sort(q + 1, q + t + 1, cmp);
for (int i = 1; i <= t; i++) {
while (l < q[i].l) del(l++);
while (l > q[i].l) add(--l);
while (r < q[i].r) add(++r);
while (r > q[i].r) del(r--);
Ans[q[i].id] = now;
}
for (int i = 1; i <= t; i++) printf("%lld\n", Ans[i]);
return 0;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
Roma is playing a new expansion for his favorite game World of Darkraft. He made a new character and is going for his first grind.
Roma has a choice to buy exactly one of n different weapons and exactly one of m different armor sets. Weapon i has attack modifier a_i and is worth ca_i coins, and armor set j has defense modifier b_j and is worth cb_j coins.
After choosing his equipment Roma can proceed to defeat some monsters. There are p monsters he can try to defeat. Monster k has defense x_k, attack y_k and possesses z_k coins. Roma can defeat a monster if his weapon's attack modifier is larger than the monster's defense, and his armor set's defense modifier is larger than the monster's attack. That is, a monster k can be defeated with a weapon i and an armor set j if a_i > x_k and b_j > y_k. After defeating the monster, Roma takes all the coins from them. During the grind, Roma can defeat as many monsters as he likes. Monsters do not respawn, thus each monster can be defeated at most one.
Thanks to Roma's excessive donations, we can assume that he has an infinite amount of in-game currency and can afford any of the weapons and armor sets. Still, he wants to maximize the profit of the grind. The profit is defined as the total coins obtained from all defeated monsters minus the cost of his equipment. Note that Roma must purchase a weapon and an armor set even if he can not cover their cost with obtained coins.
Help Roma find the maximum profit of the grind.
Input
The first line contains three integers n, m, and p (1 β€ n, m, p β€ 2 β
10^5) β the number of available weapons, armor sets and monsters respectively.
The following n lines describe available weapons. The i-th of these lines contains two integers a_i and ca_i (1 β€ a_i β€ 10^6, 1 β€ ca_i β€ 10^9) β the attack modifier and the cost of the weapon i.
The following m lines describe available armor sets. The j-th of these lines contains two integers b_j and cb_j (1 β€ b_j β€ 10^6, 1 β€ cb_j β€ 10^9) β the defense modifier and the cost of the armor set j.
The following p lines describe monsters. The k-th of these lines contains three integers x_k, y_k, z_k (1 β€ x_k, y_k β€ 10^6, 1 β€ z_k β€ 10^3) β defense, attack and the number of coins of the monster k.
Output
Print a single integer β the maximum profit of the grind.
Example
Input
2 3 3
2 3
4 7
2 4
3 2
5 11
1 2 4
2 1 6
3 4 6
Output
1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T>
inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
const long double EPS = 1e-10;
const long long INF = 1e18;
const long double PI = acos(-1.0L);
long long N, M, P;
vector<pair<long long, long long> > tmpa, tmpb;
vector<pair<long long, pair<long long, long long> > > c;
vector<pair<long long, long long> > a, b;
long long ans = -1e18;
struct LazySegmentTree {
private:
int n;
vector<long long> node, lazy;
public:
LazySegmentTree(vector<long long> v) {
int sz = (int)v.size();
n = 1;
while (n < sz) n *= 2;
node.resize(2 * n - 1);
lazy.resize(2 * n - 1, 0);
for (int i = 0; i < sz; i++) node[i + n - 1] = v[i];
for (int i = n - 2; i >= 0; i--)
node[i] = max(node[i * 2 + 1], node[i * 2 + 2]);
}
void eval(int k, int l, int r) {
if (lazy[k] != 0) {
node[k] += lazy[k];
if (r - l > 1) {
lazy[2 * k + 1] += lazy[k];
lazy[2 * k + 2] += lazy[k];
}
lazy[k] = 0;
}
}
void add(int a, int b, long long x, int k = 0, int l = 0, int r = -1) {
if (r < 0) r = n;
eval(k, l, r);
if (b <= l || r <= a) return;
if (a <= l && r <= b) {
lazy[k] += x;
eval(k, l, r);
} else {
add(a, b, x, 2 * k + 1, l, (l + r) / 2);
add(a, b, x, 2 * k + 2, (l + r) / 2, r);
node[k] = max(node[2 * k + 1], node[2 * k + 2]);
}
}
long long getmax(int a, int b, int k = 0, int l = 0, int r = -1) {
if (r < 0) r = n;
eval(k, l, r);
if (b <= l || r <= a) return -INF;
if (a <= l && r <= b) return node[k];
long long vl = getmax(a, b, 2 * k + 1, l, (l + r) / 2);
long long vr = getmax(a, b, 2 * k + 2, (l + r) / 2, r);
return max(vl, vr);
}
};
void print(LazySegmentTree seg) {
for (int i = 0; i < M; i++) {
cerr << seg.getmax(i, i + 1) << " ";
}
cerr << endl;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> N >> M >> P;
tmpa.resize(N);
tmpb.resize(M);
c.resize(P);
for (int i = 0; i < N; i++) cin >> tmpa[i].first >> tmpa[i].second;
for (int i = 0; i < M; i++) cin >> tmpb[i].first >> tmpb[i].second;
for (int i = 0; i < P; i++) {
cin >> c[i].first >> c[i].second.first >> c[i].second.second;
}
sort(tmpa.begin(), tmpa.end());
sort(tmpb.begin(), tmpb.end());
sort(c.begin(), c.end());
for (int i = 0; i < N; i++) {
while (!a.empty() and a.back().second >= tmpa[i].second) a.pop_back();
a.push_back(tmpa[i]);
}
for (int i = 0; i < M; i++) {
while (!b.empty() and b.back().second >= tmpb[i].second) b.pop_back();
b.push_back(tmpb[i]);
}
b.push_back({1e17, 1e17});
N = a.size();
M = b.size();
vector<long long> INIT;
for (int i = 0; i < M; i++) {
INIT.push_back(-b[i].second);
}
LazySegmentTree seg(INIT);
int monster = 0;
for (int i = 0; i < N; i++) {
while (monster != P and c[monster].first < a[i].first) {
pair<long long, long long> tmp = {c[monster].second.first, 1e18};
auto itr = lower_bound(b.begin(), b.end(), tmp);
int idx = distance(b.begin(), itr);
seg.add(idx, M, c[monster].second.second);
monster++;
}
long long now = seg.getmax(0, M);
chmax(ans, now - a[i].second);
}
cout << ans << endl;
return 0;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
There is a train going from Station A to Station B that costs X yen (the currency of Japan).
Also, there is a bus going from Station B to Station C that costs Y yen.
Joisino got a special ticket. With this ticket, she can take the bus for half the fare if she travels from Station A to Station B by train and then travels from Station B to Station C by bus.
How much does it cost to travel from Station A to Station C if she uses this ticket?
Constraints
* 1 \leq X,Y \leq 100
* Y is an even number.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
X Y
Output
If it costs x yen to travel from Station A to Station C, print x.
Examples
Input
81 58
Output
110
Input
4 54
Output
31
### Response
```cpp
#include<cstdio>
int main()
{
int a,b;
scanf("%d %d",&a,&b);
printf("%d\n",a+b/2);
return 0;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
You have a rooted tree consisting of n vertices. Each vertex of the tree has some color. We will assume that the tree vertices are numbered by integers from 1 to n. Then we represent the color of vertex v as cv. The tree root is a vertex with number 1.
In this problem you need to answer to m queries. Each query is described by two integers vj, kj. The answer to query vj, kj is the number of such colors of vertices x, that the subtree of vertex vj contains at least kj vertices of color x.
You can find the definition of a rooted tree by the following link: http://en.wikipedia.org/wiki/Tree_(graph_theory).
Input
The first line contains two integers n and m (2 β€ n β€ 105; 1 β€ m β€ 105). The next line contains a sequence of integers c1, c2, ..., cn (1 β€ ci β€ 105). The next n - 1 lines contain the edges of the tree. The i-th line contains the numbers ai, bi (1 β€ ai, bi β€ n; ai β bi) β the vertices connected by an edge of the tree.
Next m lines contain the queries. The j-th line contains two integers vj, kj (1 β€ vj β€ n; 1 β€ kj β€ 105).
Output
Print m integers β the answers to the queries in the order the queries appear in the input.
Examples
Input
8 5
1 2 2 3 3 2 3 3
1 2
1 5
2 3
2 4
5 6
5 7
5 8
1 2
1 3
1 4
2 3
5 3
Output
2
2
1
0
1
Input
4 1
1 2 3 4
1 2
2 3
3 4
1 1
Output
4
Note
A subtree of vertex v in a rooted tree with root r is a set of vertices {u : dist(r, v) + dist(v, u) = dist(r, u)}. Where dist(x, y) is the length (in edges) of the shortest path between vertices x and y.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000, maxm = 100000;
int n, m;
int c[maxn + 1];
int tot = -1, head[maxn + 1];
struct node1 {
int p, next;
} edge[maxn << 1];
inline void Add(int u, int v) {
edge[++tot] = (node1){v, head[u]};
head[u] = tot;
return;
}
struct node2 {
int l, r, L, k, index;
bool operator<(const node2 &Other) const {
return (L != Other.L) ? (L < Other.L) : (r < Other.r);
}
} Q[maxm + 1];
int Ans[maxn + 1];
int Loc[maxn + 1], Cnt[maxn + 1], col[maxn + 1];
void DFS(int u, int fa) {
col[Loc[u]] = c[u];
Cnt[u] = 1;
for (int i = head[u]; ~i; i = edge[i].next) {
int v = edge[i].p;
if (v == fa) continue;
Loc[v] = Loc[u] + Cnt[u];
DFS(v, u);
Cnt[u] += Cnt[v];
}
return;
}
int ct[maxn + 1], cnt[maxn + 1];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%d", &c[i]);
memset(head, -1, sizeof(head));
for (int i = 1; i < n; ++i) {
int u, v;
scanf("%d%d", &u, &v);
Add(u, v);
Add(v, u);
}
Loc[1] = 1;
DFS(1, 0);
for (int i = 1, p = sqrt(n), v; i <= m; ++i) {
scanf("%d%d", &v, &Q[i].k);
Q[i].l = Loc[v];
Q[i].r = Loc[v] + Cnt[v] - 1;
Q[i].L = Q[i].l / p;
Q[i].index = i;
}
sort(Q + 1, Q + m + 1);
for (int i = 1, l = 1, r = 0; i <= m; ++i) {
while (l > Q[i].l) ++cnt[++ct[col[--l]]];
while (r < Q[i].r) ++cnt[++ct[col[++r]]];
while (l < Q[i].l) --cnt[ct[col[l++]]--];
while (r > Q[i].r) --cnt[ct[col[r--]]--];
Ans[Q[i].index] = cnt[Q[i].k];
}
for (int i = 1; i <= m; ++i) printf("%d\n", Ans[i]);
return 0;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
<image>
One morning the Cereal Guy found out that all his cereal flakes were gone. He found a note instead of them. It turned out that his smart roommate hid the flakes in one of n boxes. The boxes stand in one row, they are numbered from 1 to n from the left to the right. The roommate left hints like "Hidden to the left of the i-th box" ("To the left of i"), "Hidden to the right of the i-th box" ("To the right of i"). Such hints mean that there are no flakes in the i-th box as well. The Cereal Guy wants to know the minimal number of boxes he necessarily needs to check to find the flakes considering all the hints. Or he wants to find out that the hints are contradictory and the roommate lied to him, that is, no box has the flakes.
Input
The first line contains two integers n and m (1 β€ n β€ 1000, 0 β€ m β€ 1000) which represent the number of boxes and the number of hints correspondingly. Next m lines contain hints like "To the left of i" and "To the right of i", where i is integer (1 β€ i β€ n). The hints may coincide.
Output
The answer should contain exactly one integer β the number of boxes that should necessarily be checked or "-1" if the hints are contradictory.
Examples
Input
2 1
To the left of 2
Output
1
Input
3 2
To the right of 1
To the right of 2
Output
1
Input
3 1
To the left of 3
Output
2
Input
3 2
To the left of 2
To the right of 1
Output
-1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, x, num, maxright_of = 1;
int main() {
cin >> n >> x;
for (auto i = 0; i < x; i++) {
string s, ss, sss, ssss;
cin >> s >> ss >> sss >> ssss >> num;
if (sss == "left") {
n = min(n, num - 1);
} else if (sss == "right") {
maxright_of = max(num + 1, maxright_of);
}
}
if (n >= maxright_of)
cout << n - maxright_of + 1;
else
cout << "-1";
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Prof. Hachioji has devised a new numeral system of integral numbers with four lowercase letters "m", "c", "x", "i" and with eight digits "2", "3", "4", "5", "6", "7", "8", "9". He doesn't use digit "0" nor digit "1" in this system.
The letters "m", "c", "x" and "i" correspond to 1000, 100, 10 and 1, respectively, and the digits "2", ...,"9" correspond to 2, ..., 9, respectively. This system has nothing to do with the Roman numeral system.
For example, character strings
> "5m2c3x4i", "m2c4i" and "5m2c3x"
correspond to the integral numbers 5234 (=5*1000+2*100+3*10+4*1), 1204 (=1000+2*100+4*1), and 5230 (=5*1000+2*100+3*10), respectively. The parts of strings in the above example, "5m", "2c", "3x" and "4i" represent 5000 (=5*1000), 200 (=2*100), 30 (=3*10) and 4 (=4*1), respectively.
Each of the letters "m", "c", "x" and "i" may be prefixed by one of the digits "2", "3", ..., "9". In that case, the prefix digit and the letter are regarded as a pair. A pair that consists of a prefix digit and a letter corresponds to an integer that is equal to the original value of the letter multiplied by the value of the prefix digit.
For each letter "m", "c", "x" and "i", the number of its occurrence in a string is at most one. When it has a prefix digit, it should appear together with the prefix digit. The letters "m", "c", "x" and "i" must appear in this order, from left to right. Moreover, when a digit exists in a string, it should appear as the prefix digit of the following letter. Each letter may be omitted in a string, but the whole string must not be empty. A string made in this manner is called an MCXI-string.
An MCXI-string corresponds to a positive integer that is the sum of the values of the letters and those of the pairs contained in it as mentioned above. The positive integer corresponding to an MCXI-string is called its MCXI-value. Moreover, given an integer from 1 to 9999, there is a unique MCXI-string whose MCXI-value is equal to the given integer. For example, the MCXI-value of an MCXI-string "m2c4i" is 1204 that is equal to `1000 + 2*100 + 4*1`. There are no MCXI-strings but "m2c4i" that correspond to 1204. Note that strings "1m2c4i", "mcc4i", "m2c0x4i", and "2cm4i" are not valid MCXI-strings. The reasons are use of "1", multiple occurrences of "c", use of "0", and the wrong order of "c" and "m", respectively.
Your job is to write a program for Prof. Hachioji that reads two MCXI-strings, computes the sum of their MCXI-values, and prints the MCXI-string corresponding to the result.
Input
The input is as follows. The first line contains a positive integer n (<= 500) that indicates the number of the following lines. The k+1 th line is the specification of the k th computation (k=1, ..., n).
> n
> specification1
> specification2
> ...
> specificationn
>
Each specification is described in a line:
> MCXI-string1 MCXI-string2
The two MCXI-strings are separated by a space.
You may assume that the sum of the two MCXI-values of the two MCXI-strings in each specification is less than or equal to 9999.
Output
For each specification, your program should print an MCXI-string in a line. Its MCXI-value should be the sum of the two MCXI-values of the MCXI-strings in the specification. No other characters should appear in the output.
Example
Input
10
xi x9i
i 9i
c2x2i 4c8x8i
m2ci 4m7c9x8i
9c9x9i i
i 9m9c9x8i
m i
i m
m9i i
9m8c7xi c2x8i
Output
3x
x
6cx
5m9c9x9i
m
9m9c9x9i
mi
mi
mx
9m9c9x9i
### Response
```cpp
#include <stdio.h>
#include <string.h>
int henkan(char x[]) {
int z = 1;
int y = 0;
int j = 0;
for (y = 0; y<10; y++) {
if (x[y] == 'm') {
j = j + z * 1000;
}
if (x[y] == 'c') {
j = j + z * 100;
}
if (x[y] == 'x') {
j = j + z * 10;
}
if (x[y] == 'i') {
j = j + z * 1;
}
if ('2' <= x[y] && x[y] <= '9') {
z = x[y]-'0';
}
else {
z = 1;
}
}
return j;
}
int main() {
int n = 0;
scanf("%d", &n);
int i = 0;
int b = 0;
int c = 0;
for (i = 0; i < n; i++) {
char a[10] = {};
char d[10] = {};
scanf("%s %s", a, d);
b = henkan(a) + henkan(d);
if ((b / 1000) > 1) {
c = b / 1000;
printf("%d", c);
}
if (b / 1000 >= 1) {
printf("m");
}
b %= 1000;
if ((b / 100) > 1) {
c = b / 100;
printf("%d", c);
}
if (b / 100 >= 1) {
printf("c");
}
b %= 100;
if ((b / 10) > 1) {
c = b / 10;
printf("%d", c);
}
if (b / 10 >= 1) {
printf("x");
}
b %= 10;
if (b > 1) {
printf("%d", b);
}
if (b >= 1) {
printf("i");
}
printf("\n");
}
return 0;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
Fox Ciel studies number theory.
She thinks a non-empty set S contains non-negative integers is perfect if and only if for any <image> (a can be equal to b), <image>. Where operation xor means exclusive or operation (http://en.wikipedia.org/wiki/Exclusive_or).
Please calculate the number of perfect sets consisting of integers not greater than k. The answer can be very large, so print it modulo 1000000007 (109 + 7).
Input
The first line contains an integer k (0 β€ k β€ 109).
Output
Print a single integer β the number of required sets modulo 1000000007 (109 + 7).
Examples
Input
1
Output
2
Input
2
Output
3
Input
3
Output
5
Input
4
Output
6
Note
In example 1, there are 2 such sets: {0} and {0, 1}. Note that {1} is not a perfect set since 1 xor 1 = 0 and {1} doesn't contain zero.
In example 4, there are 6 such sets: {0}, {0, 1}, {0, 2}, {0, 3}, {0, 4} and {0, 1, 2, 3}.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e6 + 2000;
const int MX = 1e5 + 2000;
const int inf_int = 2e9 + 100;
const long long inf_ll = 1e18;
const double PI = 3.1415926535898;
bool debug = 0;
const int MOD = 1e9 + 7;
const int MAX_BIT = 500;
int n;
long long dp[50][50][2];
long long fun(int i, int bit, bool any) {
if (bit < 0) return 1;
long long &res = dp[i][bit][any];
if (res != -1) return res;
res = 0;
if (i == 0) {
if (n & (1 << bit) || any) res += fun(1, bit - 1, any);
res += fun(0, bit - 1, any || (n & (1 << bit)));
res %= MOD;
return res;
}
if (any) {
res += fun(i + 1, bit - 1, any);
res += 1ll * fun(i, bit - 1, any) * (1 << i) % MOD;
} else {
if (n & (1 << bit)) {
res += fun(i + 1, bit - 1, 0);
res += fun(i, bit - 1, 0) * (1 << (i - 1)) % MOD;
res %= MOD;
res += fun(i, bit - 1, 1) * (1 << (i - 1)) % MOD;
} else {
res += fun(i, bit - 1, 0) * (1 << (i - 1)) % MOD;
}
}
res %= MOD;
return res;
}
void solve() {
cin >> n;
memset(dp, -1, sizeof(dp));
cout << fun(0, 30, 0);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
There are n bags with candies, initially the i-th bag contains i candies. You want all the bags to contain an equal amount of candies in the end.
To achieve this, you will:
* Choose m such that 1 β€ m β€ 1000
* Perform m operations. In the j-th operation, you will pick one bag and add j candies to all bags apart from the chosen one.
Your goal is to find a valid sequence of operations after which all the bags will contain an equal amount of candies.
* It can be proved that for the given constraints such a sequence always exists.
* You don't have to minimize m.
* If there are several valid sequences, you can output any.
Input
Each test contains multiple test cases.
The first line contains the number of test cases t (1 β€ t β€ 100). Description of the test cases follows.
The first and only line of each test case contains one integer n (2 β€ nβ€ 100).
Output
For each testcase, print two lines with your answer.
In the first line print m (1β€ m β€ 1000) β the number of operations you want to take.
In the second line print m positive integers a_1, a_2, ..., a_m (1 β€ a_i β€ n), where a_j is the number of bag you chose on the j-th operation.
Example
Input
2
2
3
Output
1
2
5
3 3 3 1 2
Note
In the first case, adding 1 candy to all bags except of the second one leads to the arrangement with [2, 2] candies.
In the second case, firstly you use first three operations to add 1+2+3=6 candies in total to each bag except of the third one, which gives you [7, 8, 3]. Later, you add 4 candies to second and third bag, so you have [7, 12, 7], and 5 candies to first and third bag β and the result is [12, 12, 12].
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
while (n--) {
int c;
cin >> c;
cout << c << " ";
for (int i = 0; i < c; i++) cout << i + 1 << " ";
}
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Write a program which manipulates a sequence A = {a0, a1, . . . , anβ1} with the following operations:
* update(s, t, x): change as, as+1, ..., at to x.
* find(s, t): report the minimum element in as, as+1, ..., at.
Note that the initial values of ai (i = 0, 1, . . . , nβ1) are 231-1.
Constraints
* 1 β€ n β€ 100000
* 1 β€ q β€ 100000
* 0 β€ s β€ t < n
* 0 β€ x < 231β1
Input
n q
query1
query2
:
queryq
In the first line, n (the number of elements in A) and q (the number of queries) are given. Then, ith query queryi is given in the following format:
0 s t x
or
1 s t
The first digit represents the type of the query. '0' denotes update(s, t, x) and '1' denotes find(s, t).
Output
For each find operation, print the minimum value.
Examples
Input
3 5
0 0 1 1
0 1 2 3
0 2 2 2
1 0 2
1 1 2
Output
1
2
Input
1 3
1 0 0
0 0 0 5
1 0 0
Output
2147483647
5
### Response
```cpp
#include <iostream>
#include <climits>
struct Node {
int key;
int lazy;
Node() {}
};
void eval(Node* segtree, int index, int l, int r)
{
if (segtree[index].lazy < INT_MAX) {
segtree[index].key = segtree[index].lazy;
if (l+1 < r) {
segtree[2*index+1].lazy = segtree[index].lazy;
segtree[2*index+2].lazy = segtree[index].lazy;
}
segtree[index].lazy = INT_MAX;
}
}
void update(Node* segtree, int s, int t, int x, int l, int r, int index, int time)
{
eval(segtree, index, l, r);
if (t<l || r<=s) return;
else if (s<=l && r<=t+1) {
//segtree[index].key = x;
segtree[index].lazy = x;
eval(segtree, index, l, r);
}
else {
int mid = (l + r) / 2;
update(segtree, s, t, x, l, mid, 2*index+1, time);
update(segtree, s, t, x, mid, r, 2*index+2, time);
segtree[index].key = std::min(segtree[2*index+1].key, segtree[2*index+2].key);
}
}
int find(Node* segtree, int s, int t, int l, int r, int index)
{
if (t<l || r<=s) return INT_MAX;
eval(segtree, index, l, r);
if (s<=l && r<=t+1) {
return segtree[index].key;
}
else {
int mid = (l + r) / 2;
int x = find(segtree, s, t, l, mid, 2*index+1);
int y = find(segtree, s, t, mid, r, 2*index+2);
return std::min(x, y);
}
}
int main()
{
int n; std::cin >> n;
int seg_size = 1;
for (; seg_size < n; seg_size<<=1);
Node* segtree = new Node[2*seg_size-1];
for (int i=0; i<2*seg_size-1; i++) {
segtree[i].key = INT_MAX;
segtree[i].lazy = INT_MAX;
}
int q; std::cin >> q;
for (int i=0; i<q; i++) {
int op, s, t, x;
std::cin >> op;
if (op==0) {
std::cin >> s >> t >> x;
update(segtree, s, t, x, 0, seg_size, 0, i);
}
else {
std::cin >> s >> t;
std::cout << find(segtree, s, t, 0, seg_size, 0) << std::endl;
}
}
delete[] segtree;
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
The Smart Beaver from ABBYY invented a new message encryption method and now wants to check its performance. Checking it manually is long and tiresome, so he decided to ask the ABBYY Cup contestants for help.
A message is a sequence of n integers a1, a2, ..., an. Encryption uses a key which is a sequence of m integers b1, b2, ..., bm (m β€ n). All numbers from the message and from the key belong to the interval from 0 to c - 1, inclusive, and all the calculations are performed modulo c.
Encryption is performed in n - m + 1 steps. On the first step we add to each number a1, a2, ..., am a corresponding number b1, b2, ..., bm. On the second step we add to each number a2, a3, ..., am + 1 (changed on the previous step) a corresponding number b1, b2, ..., bm. And so on: on step number i we add to each number ai, ai + 1, ..., ai + m - 1 a corresponding number b1, b2, ..., bm. The result of the encryption is the sequence a1, a2, ..., an after n - m + 1 steps.
Help the Beaver to write a program that will encrypt messages in the described manner.
Input
The first input line contains three integers n, m and c, separated by single spaces.
The second input line contains n integers ai (0 β€ ai < c), separated by single spaces β the original message.
The third input line contains m integers bi (0 β€ bi < c), separated by single spaces β the encryption key.
The input limitations for getting 30 points are:
* 1 β€ m β€ n β€ 103
* 1 β€ c β€ 103
The input limitations for getting 100 points are:
* 1 β€ m β€ n β€ 105
* 1 β€ c β€ 103
Output
Print n space-separated integers β the result of encrypting the original message.
Examples
Input
4 3 2
1 1 1 1
1 1 1
Output
0 1 1 0
Input
3 1 5
1 2 3
4
Output
0 1 2
Note
In the first sample the encryption is performed in two steps: after the first step a = (0, 0, 0, 1) (remember that the calculations are performed modulo 2), after the second step a = (0, 1, 1, 0), and that is the answer.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, t, a, b, c, A[100000 + 5], B[100000 + 5], m, Sum[100000 + 5],
ST[100000 + 5], EN[100000 + 5];
void solve() {
t = n - m + 1;
Sum[0] = 0;
for (int i = (1), _b = (m); i <= _b; i++) Sum[i] = Sum[i - 1] + B[i];
for (int i = (1), _b = (n); i <= _b; i++) {
if (i <= t) {
ST[i] = 1;
} else {
ST[i] = i - t + 1;
}
if (i >= m) {
EN[i] = m;
} else
EN[i] = i;
}
for (int i = (1), _b = (n); i <= _b; i++) {
A[i] = (A[i] + Sum[EN[i]] - Sum[ST[i] - 1]) % c;
}
for (int i = (1), _b = (n); i <= _b; i++) {
if (i > 1) printf(" ");
printf("%d", A[i]);
}
printf("\n");
}
int main() {
scanf("%d %d %d", &n, &m, &c);
for (int i = (1), _b = (n); i <= _b; i++) scanf("%d", &A[i]);
for (int i = (1), _b = (m); i <= _b; i++) scanf("%d", &B[i]);
solve();
return 0;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
Have you ever used the chat application QQ? Well, in a chat group of QQ, administrators can muzzle a user for days.
In Boboniu's chat group, there's a person called Du Yi who likes to make fun of Boboniu every day.
Du will chat in the group for n days. On the i-th day:
* If Du can speak, he'll make fun of Boboniu with fun factor a_i. But after that, he may be muzzled depending on Boboniu's mood.
* Otherwise, Du won't do anything.
Boboniu's mood is a constant m. On the i-th day:
* If Du can speak and a_i>m, then Boboniu will be angry and muzzle him for d days, which means that Du won't be able to speak on the i+1, i+2, β
β
β
, min(i+d,n)-th days.
* Otherwise, Boboniu won't do anything.
The total fun factor is the sum of the fun factors on the days when Du can speak.
Du asked you to find the maximum total fun factor among all possible permutations of a.
Input
The first line contains three integers n, d and m (1β€ dβ€ nβ€ 10^5,0β€ mβ€ 10^9).
The next line contains n integers a_1, a_2, β¦,a_n (0β€ a_iβ€ 10^9).
Output
Print one integer: the maximum total fun factor among all permutations of a.
Examples
Input
5 2 11
8 10 15 23 5
Output
48
Input
20 2 16
20 5 8 2 18 16 2 16 16 1 5 16 2 13 6 16 4 17 21 7
Output
195
Note
In the first example, you can set a'=[15, 5, 8, 10, 23]. Then Du's chatting record will be:
1. Make fun of Boboniu with fun factor 15.
2. Be muzzled.
3. Be muzzled.
4. Make fun of Boboniu with fun factor 10.
5. Make fun of Boboniu with fun factor 23.
Thus the total fun factor is 48.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
long long a[N], b[N], c[N];
int cmp(int a, int b) { return a > b; }
int main() {
int n, d, m;
cin >> n >> d >> m;
int toa = 1, tob = 1;
for (int i = 1; i <= n; i++) {
long long x;
cin >> x;
if (x <= m)
a[toa++] = x;
else
b[tob++] = x;
}
sort(a + 1, a + toa, cmp);
sort(b + 1, b + tob, cmp);
for (int i = 1; i <= n; i++) c[i] = c[i - 1] + a[i];
long long sum = 0, ans = c[n];
for (int j = 1; j < tob; j++) {
sum += b[j];
int y = (j - 1) * (d + 1) + 1;
if (y > n) break;
y = n - y;
ans = max(ans, sum + c[y]);
}
cout << ans << endl;
return 0;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
Rumors say that one of Kamal-ol-molk's paintings has been altered. A rectangular brush has been moved right and down on the painting.
Consider the painting as a n Γ m rectangular grid. At the beginning an x Γ y rectangular brush is placed somewhere in the frame, with edges parallel to the frame, (1 β€ x β€ n, 1 β€ y β€ m). Then the brush is moved several times. Each time the brush is moved one unit right or down. The brush has been strictly inside the frame during the painting. The brush alters every cell it has covered at some moment.
You have found one of the old Kamal-ol-molk's paintings. You want to know if it's possible that it has been altered in described manner. If yes, you also want to know minimum possible area of the brush.
Input
The first line of input contains two integers n and m, (1 β€ n, m β€ 1000), denoting the height and width of the painting.
The next n lines contain the painting. Each line has m characters. Character 'X' denotes an altered cell, otherwise it's showed by '.'. There will be at least one altered cell in the painting.
Output
Print the minimum area of the brush in a line, if the painting is possibly altered, otherwise print - 1.
Examples
Input
4 4
XX..
XX..
XXXX
XXXX
Output
4
Input
4 4
....
.XXX
.XXX
....
Output
2
Input
4 5
XXXX.
XXXX.
.XX..
.XX..
Output
-1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3fffFFFF;
char g[1010][1010];
int s[1010][1010];
int get(int x0, int y0, int wx, int wy) {
int x1 = x0 + wx - 1;
int y1 = y0 + wy - 1;
return s[x1][y1] + s[x0 - 1][y0 - 1] - s[x1][y0 - 1] - s[x0 - 1][y1];
}
int check(int x, int y, int wx, int wy) {
if (get(x + 1, y, wx, wy) == wx * wy) return wy + check(x + 1, y, wx, wy);
if (get(x, y + 1, wx, wy) == wx * wy) return wx + check(x, y + 1, wx, wy);
return 0;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%s", g[i] + 1);
}
int sx, sy, tag = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (g[i][j] == 'X') {
if (!tag) tag = 1, sx = i, sy = j;
s[i][j] = s[i - 1][j] + s[i][j - 1] - s[i - 1][j - 1] + 1;
} else {
s[i][j] = s[i - 1][j] + s[i][j - 1] - s[i - 1][j - 1] + 0;
}
}
}
int x0, y0;
for (y0 = sy; y0 <= m && g[sx][y0] == 'X'; y0++)
;
for (x0 = sx; x0 <= n && g[x0][sy] == 'X'; x0++)
;
int wx = x0 - sx, wy = y0 - sy;
int ans = INF;
for (int i = 1; i <= wx; i++) {
if (check(sx, sy, i, wy) + i * wy == s[n][m]) {
ans = min(ans, i * wy);
}
}
for (int j = 1; j <= wy; j++) {
if (check(sx, sy, wx, j) + wx * j == s[n][m]) {
ans = min(ans, wx * j);
}
}
if (ans == INF) ans = -1;
cout << ans << '\n';
return 0;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
Hamming distance between strings a and b of equal length (denoted by h(a, b)) is equal to the number of distinct integers i (1 β€ i β€ |a|), such that ai β bi, where ai is the i-th symbol of string a, bi is the i-th symbol of string b. For example, the Hamming distance between strings "aba" and "bba" equals 1, they have different first symbols. For strings "bbba" and "aaab" the Hamming distance equals 4.
John Doe had a paper on which four strings of equal length s1, s2, s3 and s4 were written. Each string si consisted only of lowercase letters "a" and "b". John found the Hamming distances between all pairs of strings he had. Then he lost the paper with the strings but he didn't lose the Hamming distances between all pairs.
Help John restore the strings; find some four strings s'1, s'2, s'3, s'4 of equal length that consist only of lowercase letters "a" and "b", such that the pairwise Hamming distances between them are the same as between John's strings. More formally, set s'i must satisfy the condition <image>.
To make the strings easier to put down on a piece of paper, you should choose among all suitable sets of strings the one that has strings of minimum length.
Input
The first line contains space-separated integers h(s1, s2), h(s1, s3), h(s1, s4). The second line contains space-separated integers h(s2, s3) and h(s2, s4). The third line contains the single integer h(s3, s4).
All given integers h(si, sj) are non-negative and do not exceed 105. It is guaranteed that at least one number h(si, sj) is positive.
Output
Print -1 if there's no suitable set of strings.
Otherwise print on the first line number len β the length of each string. On the i-th of the next four lines print string s'i. If there are multiple sets with the minimum length of the strings, print any of them.
Examples
Input
4 4 4
4 4
4
Output
6
aaaabb
aabbaa
bbaaaa
bbbbbb
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int b[11], c[11];
const int inf = 1e9;
string st[8] = {"", "aaab", "aaba", "abaa", "baaa", "aabb", "abab", "abba"};
double a[7][9] = {{0, 0, 0, 0, 0, 0, 0, 0}, {0, 0, 0, 1, 1, 0, 1, 1},
{0, 0, 1, 0, 1, 1, 0, 1}, {0, 1, 0, 0, 1, 1, 1, 0},
{0, 0, 1, 1, 0, 1, 1, 0}, {0, 1, 0, 1, 0, 1, 0, 1},
{0, 1, 1, 0, 0, 0, 1, 1}};
string ans[5];
int z[11][2] = {{0, 0}, {1, 2}, {1, 3}, {1, 4}, {2, 3}, {2, 4}, {3, 4}};
void gauss() {
for (int i = 1; i <= 6; i++) a[i][8] = b[i];
for (int i = 1; i <= 6; i++) {
int pivot = i;
for (int j = i + 1; j <= 6; j++) {
if (fabs(a[j][i]) > fabs(a[pivot][i])) {
pivot = j;
break;
}
}
for (int j = 1; j <= 8; j++) swap(a[i][j], a[pivot][j]);
if (fabs(a[i][i]) < 1e-6) continue;
for (int j = 8; j >= i; j--) a[i][j] /= a[i][i];
for (int j = 1; j <= 6; j++)
if (j != i) {
for (int p = 8; p >= i; p--) a[j][p] -= a[j][i] * a[i][p];
}
}
}
int main() {
int lim = 0;
for (int i = 1; i <= 6; i++) {
cin >> b[i];
lim += b[i];
}
gauss();
int val = inf;
for (int i = 1; i <= 6; i++)
if (!a[i][i]) {
if (!a[i][7] && a[i][8] || val < inf && val != a[i][8]) {
cout << -1;
return 0;
}
if (a[i][7]) val = a[i][8];
}
if (val == inf) {
int minv = inf;
for (int i = 0; i <= lim; i++) {
int s = i;
for (int j = 1; j <= 6; j++) {
if (a[j][8] - a[j][7] * i < -1e-6 ||
!(fabs((int)(a[j][8] - a[j][7] * i) / a[j][j] -
(a[j][8] - a[j][7] * i) / a[j][j]) < 1e-6))
s = inf;
else
s += (a[j][8] - a[j][7] * i) / a[j][j];
}
if (s < minv) minv = s, val = i;
}
if (minv >= inf) {
cout << -1;
return 0;
}
}
int tot = val;
c[7] = val;
for (int i = 1; i <= 6; i++)
c[i] = (a[i][8] - a[i][7] * val) / a[i][i], tot += c[i];
cout << tot << endl;
for (int i = 1; i <= 4; i++) ans[i] = "";
for (int i = 1; i <= 7; i++)
for (int j = 1; j <= 4; j++)
for (int p = 1; p <= c[i]; p++) {
ans[j] += st[i][j - 1];
}
for (int i = 1; i <= 4; i++) cout << ans[i] << endl;
return 0;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
Many students live in a dormitory. A dormitory is a whole new world of funny amusements and possibilities but it does have its drawbacks.
There is only one shower and there are multiple students who wish to have a shower in the morning. That's why every morning there is a line of five people in front of the dormitory shower door. As soon as the shower opens, the first person from the line enters the shower. After a while the first person leaves the shower and the next person enters the shower. The process continues until everybody in the line has a shower.
Having a shower takes some time, so the students in the line talk as they wait. At each moment of time the students talk in pairs: the (2i - 1)-th man in the line (for the current moment) talks with the (2i)-th one.
Let's look at this process in more detail. Let's number the people from 1 to 5. Let's assume that the line initially looks as 23154 (person number 2 stands at the beginning of the line). Then, before the shower opens, 2 talks with 3, 1 talks with 5, 4 doesn't talk with anyone. Then 2 enters the shower. While 2 has a shower, 3 and 1 talk, 5 and 4 talk too. Then, 3 enters the shower. While 3 has a shower, 1 and 5 talk, 4 doesn't talk to anyone. Then 1 enters the shower and while he is there, 5 and 4 talk. Then 5 enters the shower, and then 4 enters the shower.
We know that if students i and j talk, then the i-th student's happiness increases by gij and the j-th student's happiness increases by gji. Your task is to find such initial order of students in the line that the total happiness of all students will be maximum in the end. Please note that some pair of students may have a talk several times. In the example above students 1 and 5 talk while they wait for the shower to open and while 3 has a shower.
Input
The input consists of five lines, each line contains five space-separated integers: the j-th number in the i-th line shows gij (0 β€ gij β€ 105). It is guaranteed that gii = 0 for all i.
Assume that the students are numbered from 1 to 5.
Output
Print a single integer β the maximum possible total happiness of the students.
Examples
Input
0 0 0 0 9
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
7 0 0 0 0
Output
32
Input
0 43 21 18 2
3 0 21 11 65
5 2 0 1 4
54 62 12 0 99
87 64 81 33 0
Output
620
Note
In the first sample, the optimal arrangement of the line is 23154. In this case, the total happiness equals:
(g23 + g32 + g15 + g51) + (g13 + g31 + g54 + g45) + (g15 + g51) + (g54 + g45) = 32.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n = 5, sum = 0, p, q, x, y, z, mxsum = 0;
int a[5][5];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> a[i][j];
}
}
string s = {"12345"};
for (int i = 0; i < 120; i++) {
p = int(s[0]) - 49;
q = int(s[1]) - 49;
x = int(s[2]) - 49;
y = int(s[3]) - 49;
z = int(s[4]) - 49;
int sum1 = (a[p][q] + a[q][p] + a[x][y] + a[y][x]);
int sum2 = a[q][x] + a[x][q] + a[y][z] + a[z][y];
int sum3 = a[x][y] + a[y][x] + a[y][z] + a[z][y];
sum = sum1 + sum2 + sum3;
if (mxsum <= sum) {
mxsum = sum;
}
next_permutation(s.begin(), s.end());
}
cout << mxsum;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
The Little Elephant loves to play with color cards.
He has n cards, each has exactly two colors (the color of the front side and the color of the back side). Initially, all the cards lay on the table with the front side up. In one move the Little Elephant can turn any card to the other side. The Little Elephant thinks that a set of cards on the table is funny if at least half of the cards have the same color (for each card the color of the upper side is considered).
Help the Little Elephant to find the minimum number of moves needed to make the set of n cards funny.
Input
The first line contains a single integer n (1 β€ n β€ 105) β the number of the cards. The following n lines contain the description of all cards, one card per line. The cards are described by a pair of positive integers not exceeding 109 β colors of both sides. The first number in a line is the color of the front of the card, the second one β of the back. The color of the front of the card may coincide with the color of the back of the card.
The numbers in the lines are separated by single spaces.
Output
On a single line print a single integer β the sought minimum number of moves. If it is impossible to make the set funny, print -1.
Examples
Input
3
4 7
4 7
7 4
Output
0
Input
5
4 7
7 4
2 11
9 7
1 1
Output
2
Note
In the first sample there initially are three cards lying with colors 4, 4, 7. Since two of the three cards are of the same color 4, you do not need to change anything, so the answer is 0.
In the second sample, you can turn the first and the fourth cards. After that three of the five cards will be of color 7.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, mx = 0;
cin >> n;
map<int, long long int> mp1, mp2;
map<pair<long long int, long long int>, int> mp;
vector<long long int> a(n), b(n);
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
a[i] = x, b[i] = y;
mp1[x]++, mp2[y]++;
mp[{a[i], b[i]}]++;
mx = max(mx, mp2[y]);
}
long long int operations = INT_MAX;
for (int i = 0; i < n; i++) {
long long int temp = mp1[a[i]] + mp2[a[i]] - mp[{a[i], a[i]}];
if (temp >= (n + 1) / 2) {
operations =
min(operations, max(min(temp, (n + 1) / 2) - mp1[a[i]], 0LL));
}
}
if (operations == INT_MAX && mx < (n + 1) / 2) {
cout << "-1\n";
return 0;
}
if (operations == INT_MAX) {
operations = (n + 1) / 2;
}
cout << operations << endl;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
A binary search tree can be unbalanced depending on features of data. For example, if we insert $n$ elements into a binary search tree in ascending order, the tree become a list, leading to long search times. One of strategies is to randomly shuffle the elements to be inserted. However, we should consider to maintain the balanced binary tree where different operations can be performed one by one depending on requirement.
We can maintain the balanced binary search tree by assigning a priority randomly selected to each node and by ordering nodes based on the following properties. Here, we assume that all priorities are distinct and also that all keys are distinct.
* binary-search-tree property. If $v$ is a left child of $u$, then $v.key < u.key$ and if $v$ is a right child of $u$, then $u.key < v.key$
* heap property. If $v$ is a child of $u$, then $v.priority < u.priority$
This combination of properties is why the tree is called Treap (tree + heap).
An example of Treap is shown in the following figure.
<image>
Insert
To insert a new element into a Treap, first of all, insert a node which a randomly selected priority value is assigned in the same way for ordinal binary search tree. For example, the following figure shows the Treap after a node with key = 6 and priority = 90 is inserted.
<image>
It is clear that this Treap violates the heap property, so we need to modify the structure of the tree by rotate operations. The rotate operation is to change parent-child relation while maintaing the binary-search-tree property.
<image>
The rotate operations can be implemented as follows.
rightRotate(Node t)
Node s = t.left
t.left = s.right
s.right = t
return s // the new root of subtree
|
leftRotate(Node t)
Node s = t.right
t.right = s.left
s.left = t
return s // the new root of subtree
---|---
The following figure shows processes of the rotate operations after the insert operation to maintain the properties.
<image>
The insert operation with rotate operations can be implemented as follows.
insert(Node t, int key, int priority) // search the corresponding place recursively
if t == NIL
return Node(key, priority) // create a new node when you reach a leaf
if key == t.key
return t // ignore duplicated keys
if key < t.key // move to the left child
t.left = insert(t.left, key, priority) // update the pointer to the left child
if t.priority < t.left.priority // rotate right if the left child has higher priority
t = rightRotate(t)
else // move to the right child
t.right = insert(t.right, key, priority) // update the pointer to the right child
if t.priority < t.right.priority // rotate left if the right child has higher priority
t = leftRotate(t)
return t
Delete
To delete a node from the Treap, first of all, the target node should be moved until it becomes a leaf by rotate operations. Then, you can remove the node (the leaf). These processes can be implemented as follows.
delete(Node t, int key) // seach the target recursively
if t == NIL
return NIL
if key < t.key // search the target recursively
t.left = delete(t.left, key)
else if key > t.key
t.right = delete(t.right, key)
else
return _delete(t, key)
return t
_delete(Node t, int key) // if t is the target node
if t.left == NIL && t.right == NIL // if t is a leaf
return NIL
else if t.left == NIL // if t has only the right child, then perform left rotate
t = leftRotate(t)
else if t.right == NIL // if t has only the left child, then perform right rotate
t = rightRotate(t)
else // if t has both the left and right child
if t.left.priority > t.right.priority // pull up the child with higher priority
t = rightRotate(t)
else
t = leftRotate(t)
return delete(t, key)
Write a program which performs the following operations to a Treap $T$ based on the above described algorithm.
* insert ($k$, $p$): Insert a node containing $k$ as key and $p$ as priority to $T$.
* find ($k$): Report whether $T$ has a node containing $k$.
* delete ($k$): Delete a node containing $k$.
* print(): Print the keys of the binary search tree by inorder tree walk and preorder tree walk respectively.
Constraints
* The number of operations $ \leq 200,000$
* $0 \leq k, p \leq 2,000,000,000$
* The height of the binary tree does not exceed 50 if you employ the above algorithm
* The keys in the binary search tree are all different.
* The priorities in the binary search tree are all different.
* The size of output $\leq 10$ MB
Input
In the first line, the number of operations $m$ is given. In the following $m$ lines, operations represented by insert $k \; p$, find $k$, delete $k$ or print are given.
Output
For each find($k$) operation, print "yes" if $T$ has a node containing $k$, "no" if not.
In addition, for each print operation, print a list of keys obtained by inorder tree walk and preorder tree walk in a line respectively. Put a space character before each key.
Example
Input
16
insert 35 99
insert 3 80
insert 1 53
insert 14 25
insert 80 76
insert 42 3
insert 86 47
insert 21 12
insert 7 10
insert 6 90
print
find 21
find 22
delete 35
delete 99
print
Output
1 3 6 7 14 21 35 42 80 86
35 6 3 1 14 7 21 80 42 86
yes
no
1 3 6 7 14 21 42 80 86
6 3 1 80 14 7 21 42 86
### Response
```cpp
#include <iostream>
#include <sstream>
#include <cstdio>
#include <stdlib.h>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;
typedef struct node {
struct node *r;
struct node *l;
int key,priotity;
}Node;
Node* delete1(Node*,int);
Node* makeNode(int k,int p){
Node* tmp=(Node* )malloc(sizeof(Node));
tmp->key=k;
tmp->priotity=p;
tmp->l=tmp->r=NULL;
return tmp;
}
Node* righRotate(Node* t){
Node* s;
s=t->l;
t->l=s->r;
s->r=t;
return s;
}
node* leftRotate(Node* t){
Node* s;
s=t->r;
t->r=s->l;
s->l=t;
return s;
}
Node* insert(Node *t,int key,int priotity){
if(t==NULL){
//cout<<key<<endl;
return makeNode(key,priotity);
}
if(key==t->key){
//cout<<"in ="<<endl;
return t;
}
if(key<t->key){
t->l= insert(t->l,key,priotity);
//cout<<"in if"<<endl;
if(t->priotity<t->l->priotity)
t=righRotate(t);
}
else{
t->r=insert(t->r,key,priotity);
//cout<<"in else"<<endl;
if(t->priotity<t->r->priotity)
t=leftRotate(t);
}
return t;
}
void inorder(Node *node){
if(node==NULL){
return;
}
inorder(node->l);
cout<<" "<<node->key;
inorder(node->r);
}
void preorder(Node *node){
if(node==NULL){
return;
}
cout<<" "<<node->key;
preorder(node->l);
preorder(node->r);
}
Node* find(Node *t,int key){
while(t!=NULL&&key!=t->key){
if(t->key>key)t=t->l;
else t=t->r;
}
return t;
}
Node* delete2(Node* t,int key){
if(t->l==NULL&&t->r==NULL)return NULL;
else if (t->l==NULL)t=leftRotate(t);
else if(t->r==NULL)t=righRotate(t);
else {
if (t->l->priotity>t->r->priotity)
t=righRotate(t);
else
t=leftRotate(t);
}
return delete1(t,key);
}
Node* delete1(Node* t,int key){
if(t==NULL)return NULL;
if(key<t->key)t->l=delete1(t->l,key);
else if (key>t->key)t->r=delete1(t->r,key);
else return delete2(t,key);
return t;
}
int main(){
int n,i,k,p;
Node *tmp;
Node* root=NULL;
string str;
cin>>n;
for(i=0;i<n;i++){
cin>>str;
//cout<<"i="<<i<<endl;
if(str=="insert"){
cin>>k>>p;
//if(i>0)cout<<"rootkeybefor:"<<root->key<<endl;
root=insert(root,k,p);
//cout<<"rootkeyafter:"<<root->key<<endl;
}
else if(str=="find"){
cin>>k;
tmp=find(root,k);
if(tmp!=NULL)cout<<"yes"<<endl;
else cout<<"no"<<endl;
}
else if(str=="delete"){
cin>>k;
root=delete1(root,k);
}
else{
inorder(root);
cout<<endl;
preorder(root);
cout<<endl;
}
}
return 0;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
Given is a permutation P_1, \ldots, P_N of 1, \ldots, N. Find the number of integers i (1 \leq i \leq N) that satisfy the following condition:
* For any integer j (1 \leq j \leq i), P_i \leq P_j.
Constraints
* 1 \leq N \leq 2 \times 10^5
* P_1, \ldots, P_N is a permutation of 1, \ldots, N.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
P_1 ... P_N
Output
Print the number of integers i that satisfy the condition.
Examples
Input
5
4 2 5 1 3
Output
3
Input
4
4 3 2 1
Output
4
Input
6
1 2 3 4 5 6
Output
1
Input
8
5 7 4 2 6 8 1 3
Output
4
Input
1
1
Output
1
### Response
```cpp
#include <cstdio>
using namespace std;
const int INF = 200005;
int N, ans;
int main() {
scanf("%d", &N);
for(int i = 1, P, min = INF; i<= N; ++i) {
scanf("%d", &P);
if(min > P) min = P, ++ans;
}
printf("%d\n", ans);
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
You are an experienced Codeforces user. Today you found out that during your activity on Codeforces you have made y submissions, out of which x have been successful. Thus, your current success rate on Codeforces is equal to x / y.
Your favorite rational number in the [0;1] range is p / q. Now you wonder: what is the smallest number of submissions you have to make if you want your success rate to be p / q?
Input
The first line contains a single integer t (1 β€ t β€ 1000) β the number of test cases.
Each of the next t lines contains four integers x, y, p and q (0 β€ x β€ y β€ 109; 0 β€ p β€ q β€ 109; y > 0; q > 0).
It is guaranteed that p / q is an irreducible fraction.
Hacks. For hacks, an additional constraint of t β€ 5 must be met.
Output
For each test case, output a single integer equal to the smallest number of submissions you have to make if you want your success rate to be equal to your favorite rational number, or -1 if this is impossible to achieve.
Example
Input
4
3 10 1 2
7 14 3 8
20 70 2 7
5 6 1 1
Output
4
10
0
-1
Note
In the first example, you have to make 4 successful submissions. Your success rate will be equal to 7 / 14, or 1 / 2.
In the second example, you have to make 2 successful and 8 unsuccessful submissions. Your success rate will be equal to 9 / 24, or 3 / 8.
In the third example, there is no need to make any new submissions. Your success rate is already equal to 20 / 70, or 2 / 7.
In the fourth example, the only unsuccessful submission breaks your hopes of having the success rate equal to 1.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long tc, x, y, p, q;
cin >> tc;
while (tc--) {
cin >> x >> y >> p >> q;
if (p == 0) {
if (x == 0)
cout << 0 << endl;
else
cout << (-1) << endl;
} else {
long long l = 1, h = 10000000000, m, ans = -1;
while (l <= h) {
m = (l + h) / 2;
if ((p * m) >= x && (q * m) >= y && (q * m - y) >= (p * m - x))
ans = q * m - y, h = m - 1;
else
l = m + 1;
}
cout << ans << endl;
}
}
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
You're given an array a. You should repeat the following operation k times: find the minimum non-zero element in the array, print it, and then subtract it from all the non-zero elements of the array. If all the elements are 0s, just print 0.
Input
The first line contains integers n and k (1 β€ n,k β€ 10^5), the length of the array and the number of operations you should perform.
The second line contains n space-separated integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9), the elements of the array.
Output
Print the minimum non-zero element before each operation in a new line.
Examples
Input
3 5
1 2 3
Output
1
1
1
0
0
Input
4 2
10 3 5 3
Output
3
2
Note
In the first sample:
In the first step: the array is [1,2,3], so the minimum non-zero element is 1.
In the second step: the array is [0,1,2], so the minimum non-zero element is 1.
In the third step: the array is [0,0,1], so the minimum non-zero element is 1.
In the fourth and fifth step: the array is [0,0,0], so we printed 0.
In the second sample:
In the first step: the array is [10,3,5,3], so the minimum non-zero element is 3.
In the second step: the array is [7,0,2,0], so the minimum non-zero element is 2.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int i, j, n, k, t, c = n, a[500000], m;
cin >> n >> m;
for (i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
if (n == 1) {
cout << a[0] << endl;
m--;
if (m > 0) {
while (m--) cout << 0 << endl;
}
} else {
cout << a[0] << endl;
m--;
for (i = 1; i < n; i++) {
if (m <= 0) break;
if (a[i - 1] == a[i]) {
continue;
}
cout << a[i] - a[i - 1] << endl;
m--, c--;
}
if (m > 0) {
if (m > 0) {
while (m--) cout << 0 << endl;
}
}
}
}
``` |
### Prompt
Create a solution in cpp for 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 <iostream>
#include <vector>
using namespace std;
int N, K, A, B;
int dfs(vector< vector< vector<int> > >& dp,vector<bool>& dec, vector<int>& pasta,int pppasta,int ppasta,int n)
{
if (n == N + 1)
return 1;
if (dp[pppasta][ppasta][n] != -1) {
return dp[pppasta][ppasta][n];
}
dp[pppasta][ppasta][n] = 0;
if (dec[n]) {
if (n - 2 >= 0 && pppasta == ppasta && ppasta == pasta[n])
return 0;
else
return dp[pppasta][ppasta][n] = dfs(dp, dec, pasta, ppasta, pasta[n], n + 1);
}
for (int i = 1; i <= 3; i++) {
pasta[n] = i;
if (n - 2 >= 0 && pppasta == ppasta && ppasta == pasta[n])
continue;
dp[pppasta][ppasta][n] += dfs(dp, dec, pasta, ppasta, pasta[n], n + 1);
}
dp[pppasta][ppasta][n] %= 10000;
return dp[pppasta][ppasta][n];
}
int main()
{
cin >> N >> K;
vector<bool> dec(N + 1, false);
vector<int> pasta(N + 1, 0);
vector< vector< vector<int> > > dp(4, vector< vector<int> >(4, vector<int>(N + 1, -1)));
for (int i = 0; i < K; i++) {
cin >> A >> B;
dec[A] = true;
pasta[A] = B;
}
cout << dfs(dp, dec, pasta, 0, 0, 1) << endl;
return 0;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
Transformation
Write a program which performs a sequence of commands to a given string $str$. The command is one of:
* print a b: print from the a-th character to the b-th character of $str$
* reverse a b: reverse from the a-th character to the b-th character of $str$
* replace a b p: replace from the a-th character to the b-th character of $str$ with p
Note that the indices of $str$ start with 0.
Constraints
* $1 \leq $ length of $str \leq 1000$
* $1 \leq q \leq 100$
* $0 \leq a \leq b < $ length of $str$
* for replace command, $b - a + 1 = $ length of $p$
Input
In the first line, a string $str$ is given. $str$ consists of lowercase letters. In the second line, the number of commands q is given. In the next q lines, each command is given in the above mentioned format.
Output
For each print command, print a string in a line.
Examples
Input
abcde
3
replace 1 3 xyz
reverse 0 2
print 1 4
Output
xaze
Input
xyz
3
print 0 2
replace 0 2 abc
print 0 2
Output
xyz
abc
### Response
```cpp
#include<iostream>
#include<string>
using namespace std;
int main(){
string str,str2,cmd,p;
int q,a,b;
cin>>str;
cin>>q;
for(int k=0;k<q;k++){
cin>>cmd;
if(cmd=="print"){
cin>>a>>b;
str2=str.substr(a,b-a+1);
cout<<str2<<endl;
}
else if(cmd=="reverse"){
cin>>a>>b;
str2=str.substr(a,b-a+1);
int j=0;
for(int i=b;i>=a;i--){
str[i]=str2[j];
j++;
}
}
else if(cmd=="replace"){
cin>>a>>b>>p;
int m=0;
for(int i=a;i<=b;i++){
str[i]=p[m];
m++;
}
}
}
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
You are given a permutation of the numbers 1, 2, ..., n and m pairs of positions (aj, bj).
At each step you can choose a pair from the given positions and swap the numbers in that positions. What is the lexicographically maximal permutation one can get?
Let p and q be two permutations of the numbers 1, 2, ..., n. p is lexicographically smaller than the q if a number 1 β€ i β€ n exists, so pk = qk for 1 β€ k < i and pi < qi.
Input
The first line contains two integers n and m (1 β€ n, m β€ 106) β the length of the permutation p and the number of pairs of positions.
The second line contains n distinct integers pi (1 β€ pi β€ n) β the elements of the permutation p.
Each of the last m lines contains two integers (aj, bj) (1 β€ aj, bj β€ n) β the pairs of positions to swap. Note that you are given a positions, not the values to swap.
Output
Print the only line with n distinct integers p'i (1 β€ p'i β€ n) β the lexicographically maximal permutation one can get.
Example
Input
9 6
1 2 3 4 5 6 7 8 9
1 4
4 7
2 5
5 8
3 6
6 9
Output
7 8 9 4 5 6 1 2 3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7, mod1 = 1e9 + 9;
const long long N = 1000005;
vector<long long> v, v2;
int a[N], vis[N];
vector<long long> ed[N];
void dfs(int in) {
vis[in] = 1;
v.push_back((a[in]));
v2.push_back(in);
for (auto x : ed[in]) {
if (!vis[x]) dfs(x);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
int n, m;
cin >> n >> m;
for (long long i = 1; i <= (n); i++) cin >> a[i];
for (long long i = 0; i < (m); i++) {
int x, y;
cin >> x >> y;
ed[x].push_back(y), ed[y].push_back(x);
}
for (long long i = 1; i <= (n); i++) {
if (!vis[i])
dfs(i);
else
continue;
sort((v).begin(), (v).end());
reverse((v).begin(), (v).end());
sort((v2).begin(), (v2).end());
for (long long i = 0; i < ((int)v.size()); i++) {
a[v2[i]] = v[i];
}
v.clear();
v2.clear();
}
for (long long i = 1; i <= (n); i++) cout << a[i] << ' ';
return 0;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
Have you ever used the chat application QQ? Well, in a chat group of QQ, administrators can muzzle a user for days.
In Boboniu's chat group, there's a person called Du Yi who likes to make fun of Boboniu every day.
Du will chat in the group for n days. On the i-th day:
* If Du can speak, he'll make fun of Boboniu with fun factor a_i. But after that, he may be muzzled depending on Boboniu's mood.
* Otherwise, Du won't do anything.
Boboniu's mood is a constant m. On the i-th day:
* If Du can speak and a_i>m, then Boboniu will be angry and muzzle him for d days, which means that Du won't be able to speak on the i+1, i+2, β
β
β
, min(i+d,n)-th days.
* Otherwise, Boboniu won't do anything.
The total fun factor is the sum of the fun factors on the days when Du can speak.
Du asked you to find the maximum total fun factor among all possible permutations of a.
Input
The first line contains three integers n, d and m (1β€ dβ€ nβ€ 10^5,0β€ mβ€ 10^9).
The next line contains n integers a_1, a_2, β¦,a_n (0β€ a_iβ€ 10^9).
Output
Print one integer: the maximum total fun factor among all permutations of a.
Examples
Input
5 2 11
8 10 15 23 5
Output
48
Input
20 2 16
20 5 8 2 18 16 2 16 16 1 5 16 2 13 6 16 4 17 21 7
Output
195
Note
In the first example, you can set a'=[15, 5, 8, 10, 23]. Then Du's chatting record will be:
1. Make fun of Boboniu with fun factor 15.
2. Be muzzled.
3. Be muzzled.
4. Make fun of Boboniu with fun factor 10.
5. Make fun of Boboniu with fun factor 23.
Thus the total fun factor is 48.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100010;
int a[MAXN], small[MAXN], large[MAXN];
long long sum_small[MAXN];
int main() {
int n, d, m;
scanf("%d %d %d", &n, &d, &m);
int cnt_small = 0, cnt_large = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (a[i] > m) {
large[++cnt_large] = a[i];
} else {
small[++cnt_small] = a[i];
}
}
if (cnt_large == 0) {
printf("%lld\n", accumulate(a + 1, a + n + 1, 0ll));
return 0;
}
sort(large + 1, large + cnt_large + 1);
sort(small + 1, small + cnt_small + 1);
reverse(small + 1, small + cnt_small + 1);
for (int i = 1; i <= cnt_small; i++) {
sum_small[i] = sum_small[i - 1] + small[i];
}
long long ans = 0;
cnt_large -= 1;
n -= 1;
long long sum_larges = 0;
for (int larges_taken = 0; larges_taken <= min(cnt_large, n / (d + 1));
larges_taken += 1) {
if (larges_taken > 0) sum_larges += large[cnt_large + 1 - larges_taken];
int smallest_deleted =
max(0, d * larges_taken - (cnt_large - larges_taken));
if (smallest_deleted > cnt_small) continue;
ans = max(ans, sum_larges + sum_small[cnt_small - smallest_deleted]);
}
ans += large[cnt_large + 1];
printf("%lld\n", ans);
return 0;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
In the final of CODE FESTIVAL in some year, there are N participants. The height and power of Participant i is H_i and P_i, respectively.
Ringo is hosting a game of stacking zabuton (cushions).
The participants will line up in a row in some order, and they will in turn try to add zabuton to the stack of zabuton. Initially, the stack is empty. When it is Participant i's turn, if there are H_i or less zabuton already stacked, he/she will add exactly P_i zabuton to the stack. Otherwise, he/she will give up and do nothing.
Ringo wants to maximize the number of participants who can add zabuton to the stack. How many participants can add zabuton to the stack in the optimal order of participants?
Constraints
* 1 \leq N \leq 5000
* 0 \leq H_i \leq 10^9
* 1 \leq P_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
H_1 P_1
H_2 P_2
:
H_N P_N
Output
Print the maximum number of participants who can add zabuton to the stack.
Examples
Input
3
0 2
1 3
3 4
Output
2
Input
3
2 4
3 1
4 1
Output
3
Input
10
1 3
8 4
8 3
9 1
6 4
2 3
4 2
9 2
8 3
0 1
Output
5
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5000 + 10;
const long long INF = (long long)(1e15);
struct Box {
int w, s;
};
int n;
Box a[MAXN];
long long f[MAXN][MAXN];
bool cmp(Box &a, Box &b) {
return a.w + a.s < b.w + b.s;
}
void minmize(long long &a, long long b) {
a = min(a, b);
}
int main() {
cin >> n;
for(int i = 1; i <= n; ++i) cin >> a[i].s >> a[i].w;
sort(a + 1, a + n + 1, cmp);
for(int i = 0; i <= n; ++i)
for(int j = 0; j <= n; ++j)
f[i][j] = INF;
f[0][0] = 0;
for(int i = 0; i < n; ++i)
for(int j = 0; j <= i; j++)
if (f[i][j] < INF) {
// not put i+1
minmize(f[i + 1][j], f[i][j]);
// put i+1
if (a[i + 1].s >= f[i][j])
minmize(f[i + 1][j + 1], f[i][j] + a[i + 1].w);
}
int res = 0;
for(int i = 0; i <= n; ++i)
if (f[n][i] < INF)
res = i;
cout << res << "\n";
}
``` |
### Prompt
Generate a cpp solution to the following problem:
We have a sandglass that runs for X seconds. The sand drops from the upper bulb at a rate of 1 gram per second. That is, the upper bulb initially contains X grams of sand.
How many grams of sand will the upper bulb contains after t seconds?
Constraints
* 1β€Xβ€10^9
* 1β€tβ€10^9
* X and t are integers.
Input
The input is given from Standard Input in the following format:
X t
Output
Print the number of sand in the upper bulb after t second.
Examples
Input
100 17
Output
83
Input
48 58
Output
0
Input
1000000000 1000000000
Output
0
### Response
```cpp
#include<bits/stdc++.h>
int main(){
int a,b;std::cin>>a>>b;
std::cout<<std::max(0,a-b)<<std::endl;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
Given is a string S. Each character in S is either a digit (`0`, ..., `9`) or `?`.
Among the integers obtained by replacing each occurrence of `?` with a digit, how many have a remainder of 5 when divided by 13? An integer may begin with 0.
Since the answer can be enormous, print the count modulo 10^9+7.
Constraints
* S is a string consisting of digits (`0`, ..., `9`) and `?`.
* 1 \leq |S| \leq 10^5
Input
Input is given from Standard Input in the following format:
S
Output
Print the number of integers satisfying the condition, modulo 10^9+7.
Examples
Input
??2??5
Output
768
Input
?44
Output
1
Input
7?4
Output
0
Input
?6?42???8??2??06243????9??3???7258??5??7???????774????4?1??17???9?5?70???76???
Output
153716888
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int const N=5e5;
int dp[N][15];
int n;
string s;
int rec(int idx,int md){
int &ret=dp[idx][md];
if(ret!=-1)return ret;
if(idx==n)return ret=md==5;
ret=0;
if(s[idx]=='?'){
for(int i=0;i<10;i++){
ret+=rec(idx+1,(10*md+i)%13);
ret%=(1000000007);
}
return ret;
}else{
return ret=rec(idx+1,(10*md+(s[idx]-'0'))%13);
}
}
int main() {
cin>>s;
n=s.size();
memset(dp,-1,sizeof dp);
cout<<rec(0,0);
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
During one of the space missions, humans have found an evidence of previous life at one of the planets. They were lucky enough to find a book with birth and death years of each individual that had been living at this planet. What's interesting is that these years are in the range (1, 10^9)! Therefore, the planet was named Longlifer.
In order to learn more about Longlifer's previous population, scientists need to determine the year with maximum number of individuals that were alive, as well as the number of alive individuals in that year. Your task is to help scientists solve this problem!
Input
The first line contains an integer n (1 β€ n β€ 10^5) β the number of people.
Each of the following n lines contain two integers b and d (1 β€ b < d β€ 10^9) representing birth and death year (respectively) of each individual.
Output
Print two integer numbers separated by blank character, y β the year with a maximum number of people alive and k β the number of people alive in year y.
In the case of multiple possible solutions, print the solution with minimum year.
Examples
Input
3
1 5
2 4
5 6
Output
2 2
Input
4
3 4
4 5
4 6
8 10
Output
4 2
Note
You can assume that an individual living from b to d has been born at the beginning of b and died at the beginning of d, and therefore living for d - b years.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n;
cin >> n;
long long b[n], d[n];
priority_queue<long long, vector<long long>, greater<long long>> pq;
map<long long, long long> mp;
for (long long i = 0; i < n; i++) {
cin >> b[i] >> d[i];
pq.push(b[i]);
pq.push(d[i]);
mp[b[i]]++;
mp[d[i]]--;
}
long long year, ans = 0, s = 0, y;
while (!pq.empty()) {
long long x = pq.top();
if (y == x) {
pq.pop();
continue;
}
s += (mp[x]);
if (ans < s) {
ans = s;
year = x;
}
y = x;
pq.pop();
}
cout << year << " " << ans;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
Momiji has got a rooted tree, consisting of n nodes. The tree nodes are numbered by integers from 1 to n. The root has number 1. Momiji decided to play a game on this tree.
The game consists of several steps. On each step, Momiji chooses one of the remaining tree nodes (let's denote it by v) and removes all the subtree nodes with the root in node v from the tree. Node v gets deleted as well. The game finishes when the tree has no nodes left. In other words, the game finishes after the step that chooses the node number 1.
Each time Momiji chooses a new node uniformly among all the remaining nodes. Your task is to find the expectation of the number of steps in the described game.
Input
The first line contains integer n (1 β€ n β€ 105) β the number of nodes in the tree. The next n - 1 lines contain the tree edges. The i-th line contains integers ai, bi (1 β€ ai, bi β€ n; ai β bi) β the numbers of the nodes that are connected by the i-th edge.
It is guaranteed that the given graph is a tree.
Output
Print a single real number β the expectation of the number of steps in the described game.
The answer will be considered correct if the absolute or relative error doesn't exceed 10 - 6.
Examples
Input
2
1 2
Output
1.50000000000000000000
Input
3
1 2
1 3
Output
2.00000000000000000000
Note
In the first sample, there are two cases. One is directly remove the root and another is remove the root after one step. Thus the expected steps are:
1 Γ (1 / 2) + 2 Γ (1 / 2) = 1.5
In the second sample, things get more complex. There are two cases that reduce to the first sample, and one case cleaned at once. Thus the expected steps are:
1 Γ (1 / 3) + (1 + 1.5) Γ (2 / 3) = (1 / 3) + (5 / 3) = 2
### Response
```cpp
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:66777216")
#pragma hdrstop
using namespace std;
inline void sIO() {}
inline void iIO() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
inline void fIO(string fn) {
freopen((fn + ".in").c_str(), "r", stdin);
freopen((fn + ".out").c_str(), "w", stdout);
}
inline void TM() {}
inline void swap(short& a, short& b) { b ^= a ^= b ^= a; }
inline void swap(int& a, int& b) { b ^= a ^= b ^= a; }
inline void swap(char& a, char& b) { b ^= a ^= b ^= a; }
inline void swap(long long& a, long long& b) { b ^= a ^= b ^= a; }
template <class T>
inline T abs(T x) {
return x < 0 ? -x : x;
}
template <class T>
inline T sqr(T x) {
return x * x;
}
template <class T>
inline T min(T& a, T& b) {
return a < b ? a : b;
}
template <class T>
inline T max(T& a, T& b) {
return b < a ? a : b;
}
template <class T>
inline T gcd(T a, T b) {
if (a < b) swap(a, b);
while (b) {
a %= b;
swap(a, b);
}
return a;
}
template <class T>
inline T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
template <class T>
inline bool isPrime(T n) {
if (n < 2) return false;
T kk = (T)sqrt(n + 0.);
for (T i = 2; i <= kk; ++i)
if (!(n % i)) return false;
return true;
}
template <class T>
inline string toa(T x) {
stringstream ss;
ss << x;
string ret;
ss >> ret;
return ret;
}
template <class T>
inline T ppow(T a, long long b) {
T ret = 1;
while (b) {
if (b & 1) ret *= a;
a *= a;
b >>= 1;
}
return ret;
}
template <class T>
inline T ppow(T a, long long b, long long md) {
T ret = 1;
a %= md;
while (b) {
if (b & 1) ret = ret * a % md;
a = a * a % md;
b >>= 1;
}
return ret % md;
}
inline int toi(string s) {
stringstream ss;
ss << s;
int ret;
ss >> ret;
return ret;
}
inline long long tol(string s) {
stringstream ss;
ss << s;
long long ret;
ss >> ret;
return ret;
}
inline int Random() { return ((rand() << 16) | rand()); }
inline int Random(int l, int r) {
if (l == r) return l;
return Random() % (r - l) + l;
}
inline char upperCase(char ch) {
return (ch >= 'a' && ch <= 'z') ? ch ^ 32 : ch;
}
inline char lowerCase(char ch) {
return (ch >= 'A' && ch <= 'Z') ? ch ^ 32 : ch;
}
inline string upperCase(string s) {
int ls = s.length();
for (int i = 0; i < ls; ++i)
if (s[i] >= 'a' && s[i] <= 'z') s[i] ^= 32;
return s;
}
inline string lowerCase(string s) {
int ls = s.length();
for (int i = 0; i < ls; ++i)
if (s[i] >= 'A' && s[i] <= 'Z') s[i] ^= 32;
return s;
}
inline int dig(char ch) { return ch - 48; }
inline bool isAlpha(char ch) {
return (ch >= 'A' && ch <= 'Z' || ch >= 'a' && ch <= 'z');
}
inline bool isDigit(char ch) { return (ch >= '0' && ch <= '9'); }
inline bool isLowerCase(char ch) { return (ch >= 'a' && ch <= 'z'); }
inline bool isUpperCase(char ch) { return (ch >= 'A' && ch <= 'Z'); }
int __;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fLL;
const double EPS = 1e-9;
const int MD = 1000000007;
int n, x, y;
vector<int> g[111111];
double ans;
void dfs(int v, int p, int cur) {
ans += 1. / cur;
int tt = (int)g[v].size(), to;
for (int i = 0; i < tt; ++i)
if ((to = g[v][i]) != p) dfs(to, v, cur + 1);
}
int main() {
sIO();
scanf("%d", &n);
for (int i = 1; i < n; ++i)
scanf("%d%d", &x, &y), g[x].push_back(y), g[y].push_back(x);
ans = 0, dfs(1, 0, 1);
printf("%.16lf", ans);
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
C --Misawa's rooted tree
Problem Statement
You noticed that your best friend Misawa's birthday was near, and decided to give him a rooted binary tree as a gift. Here, the rooted binary tree has the following graph structure. (Figure 1)
* Each vertex has exactly one vertex called the parent of that vertex, which is connected to the parent by an edge. However, only one vertex, called the root, has no parent as an exception.
* Each vertex has or does not have exactly one vertex called the left child. If you have a left child, it is connected to the left child by an edge, and the parent of the left child is its apex.
* Each vertex has or does not have exactly one vertex called the right child. If you have a right child, it is connected to the right child by an edge, and the parent of the right child is its apex.
<image>
Figure 1. An example of two rooted binary trees and their composition
You wanted to give a handmade item, so I decided to buy two commercially available rooted binary trees and combine them on top of each other to make one better rooted binary tree. Each vertex of the two trees you bought has a non-negative integer written on it. Mr. Misawa likes a tree with good cost performance, such as a small number of vertices and large numbers, so I decided to create a new binary tree according to the following procedure.
1. Let the sum of the integers written at the roots of each of the two binary trees be the integers written at the roots of the new binary tree.
2. If both binary trees have a left child, create a binary tree by synthesizing each of the binary trees rooted at them, and use it as the left child of the new binary tree root. Otherwise, the root of the new bifurcation has no left child.
3. If the roots of both binaries have the right child, create a binary tree by synthesizing each of the binary trees rooted at them, and use it as the right child of the root of the new binary tree. Otherwise, the root of the new bifurcation has no right child.
You decide to see what the resulting rooted binary tree will look like before you actually do the compositing work. Given the information of the two rooted binary trees you bought, write a program to find the new rooted binary tree that will be synthesized according to the above procedure.
Here, the information of the rooted binary tree is expressed as a character string in the following format.
> (String representing the left child) [Integer written at the root] (String representing the right child)
A tree without nodes is an empty string. For example, the synthesized new rooted binary tree in Figure 1 is `(() [6] ()) [8] (((() [4] ()) [7] ()) [9] () ) `Written as.
Input
The input is expressed in the following format.
$ A $
$ B $
$ A $ and $ B $ are character strings that represent the information of the rooted binary tree that you bought, and the length is $ 7 $ or more and $ 1000 $ or less. The information given follows the format described above and does not include extra whitespace. Also, rooted trees that do not have nodes are not input. You can assume that the integers written at each node are greater than or equal to $ 0 $ and less than or equal to $ 1000 $. However, note that the integers written at each node of the output may not fall within this range.
Output
Output the information of the new rooted binary tree created by synthesizing the two rooted binary trees in one line. In particular, be careful not to include extra whitespace characters other than line breaks at the end of the line.
Sample Input 1
((() [8] ()) [2] ()) [5] (((() [2] ()) [6] (() [3] ())) [1] ())
(() [4] ()) [3] (((() [2] ()) [1] ()) [8] (() [3] ()))
Output for the Sample Input 1
(() [6] ()) [8] (((() [4] ()) [7] ()) [9] ())
Sample Input 2
(() [1] ()) [2] (() [3] ())
(() [1] (() [2] ())) [3] ()
Output for the Sample Input 2
(() [2] ()) [5] ()
Sample Input 3
(() [1] ()) [111] ()
() [999] (() [9] ())
Output for the Sample Input 3
() [1110] ()
Sample Input 4
(() [2] (() [4] ())) [8] ((() [16] ()) [32] (() [64] ()))
((() [1] ()) [3] ()) [9] (() [27] (() [81] ()))
Output for the Sample Input 4
(() [5] ()) [17] (() [59] (() [145] ()))
Sample Input 5
() [0] ()
() [1000] ()
Output for the Sample Input 5
() [1000] ()
Example
Input
((()[8]())[2]())[5](((()[2]())[6](()[3]()))[1]())
(()[4]())[3](((()[2]())[1]())[8](()[3]()))
Output
(()[6]())[8](((()[4]())[7]())[9]())
### Response
```cpp
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0; i<(n); i++)
using namespace std;
struct node{
int v;
vector<node> l;
vector<node> r;
void out(){
//cout << "out " << (int)v << " " << (int)l.size() << endl;
cout << "(";
if( !l.empty() ) l.back().out();
cout << ")[" << v << "](";
if( !r.empty() ) r.back().out();
cout << ")";
}
};
node parse(int &p, string &S){
node ret;
p++;
if( S[p] != ')' ){
ret.l.push_back( parse(p, S) );
//while( S[p] != ')' ) p++;
}
p++;
p++;
int val=0;
while( S[p] != ']' ){
val = val * 10 + (S[p]-'0');
p++;
}
ret.v = val;
p++;
p++;
if( S[p] != ')' ){
ret.r.push_back( parse(p, S) );
//while( S[p] != ')' ) p++;
}
p++;
return ret;
}
node merge(node &n1, node &n2){
node ret;
ret.v = n1.v + n2.v;
if( !n1.l.empty() && !n2.l.empty() ){
ret.l.push_back( merge(n1.l[0], n2.l[0]) );
}
if( !n1.r.empty() && !n2.r.empty() ){
ret.r.push_back( merge(n1.r[0], n2.r[0]) );
}
return ret;
}
int main(){
int N, M, T, cur=0, ans=0;
string S1, S2;
cin >> S1 >> S2;
int p1=0, p2=0;
node n1 = parse(p1, S1);
node n2 = parse(p2, S2);
//n1.out();
//cout << endl;
//n2.out();
//cout << endl;
merge( n1, n2 ).out();
cout << endl;
return 0;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
You are given n pairwise non-collinear two-dimensional vectors. You can make shapes in the two-dimensional plane with these vectors in the following fashion:
1. Start at the origin (0, 0).
2. Choose a vector and add the segment of the vector to the current point. For example, if your current point is at (x, y) and you choose the vector (u, v), draw a segment from your current point to the point at (x + u, y + v) and set your current point to (x + u, y + v).
3. Repeat step 2 until you reach the origin again.
You can reuse a vector as many times as you want.
Count the number of different, non-degenerate (with an area greater than 0) and convex shapes made from applying the steps, such that the shape can be contained within a m Γ m square, and the vectors building the shape are in counter-clockwise fashion. Since this number can be too large, you should calculate it by modulo 998244353.
Two shapes are considered the same if there exists some parallel translation of the first shape to another.
A shape can be contained within a m Γ m square if there exists some parallel translation of this shape so that every point (u, v) inside or on the border of the shape satisfies 0 β€ u, v β€ m.
Input
The first line contains two integers n and m β the number of vectors and the size of the square (1 β€ n β€ 5, 1 β€ m β€ 10^9).
Each of the next n lines contains two integers x_i and y_i β the x-coordinate and y-coordinate of the i-th vector (|x_i|, |y_i| β€ 4, (x_i, y_i) β (0, 0)).
It is guaranteed, that no two vectors are parallel, so for any two indices i and j such that 1 β€ i < j β€ n, there is no real value k such that x_i β
k = x_j and y_i β
k = y_j.
Output
Output a single integer β the number of satisfiable shapes by modulo 998244353.
Examples
Input
3 3
-1 0
1 1
0 -1
Output
3
Input
3 3
-1 0
2 2
0 -1
Output
1
Input
3 1776966
-1 0
3 3
0 -2
Output
296161
Input
4 15
-4 -4
-1 1
-1 -4
4 3
Output
1
Input
5 10
3 -4
4 -3
1 -3
2 -3
-3 -4
Output
0
Input
5 1000000000
-2 4
2 -3
0 -4
2 4
-1 -3
Output
9248783
Note
The shapes for the first sample are:
<image>
The only shape for the second sample is:
<image>
The only shape for the fourth sample is:
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void solve();
using ll = long long;
template <class T = ll>
using V = vector<T>;
using vi = V<int>;
using vl = V<>;
using vvi = V<V<int> >;
constexpr int inf = 1001001001;
constexpr ll infLL = (1LL << 61) - 1;
struct IoSetupNya {
IoSetupNya() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
cerr << fixed << setprecision(7);
}
} iosetupnya;
template <typename T, typename U>
inline bool amin(T &x, U y) {
return (y < x) ? (x = y, true) : false;
}
template <typename T, typename U>
inline bool amax(T &x, U y) {
return (x < y) ? (x = y, true) : false;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << p.first << " " << p.second;
return os;
}
template <typename T, typename U>
istream &operator>>(istream &is, pair<T, U> &p) {
is >> p.first >> p.second;
return is;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
int s = (int)v.size();
for (long long i = 0; i < (long long)(s); i++) os << (i ? " " : "") << v[i];
return os;
}
template <typename T>
istream &operator>>(istream &is, vector<T> &v) {
for (auto &x : v) is >> x;
return is;
}
void in() {}
template <typename T, class... U>
void in(T &t, U &...u) {
cin >> t;
in(u...);
}
void out() { cout << "\n"; }
template <typename T, class... U>
void out(const T &t, const U &...u) {
cout << t;
if (sizeof...(u)) cout << " ";
out(u...);
}
template <typename T>
void die(T x) {
out(x);
exit(0);
}
int main() { solve(); }
using vd = V<double>;
using vs = V<string>;
using vvl = V<V<> >;
template <typename T>
using heap = priority_queue<T, V<T>, greater<T> >;
using P = pair<int, int>;
using vp = V<P>;
constexpr int MOD = 998244353;
template <int mod>
struct ModInt {
int x;
ModInt() : x(0) {}
ModInt(int64_t y) : x(y >= 0 ? y % mod : (mod - (-y) % mod) % mod) {}
ModInt &operator+=(const ModInt &p) {
if ((x += p.x) >= mod) x -= mod;
return *this;
}
ModInt &operator-=(const ModInt &p) {
if ((x += mod - p.x) >= mod) x -= mod;
return *this;
}
ModInt &operator*=(const ModInt &p) {
x = (int)(1LL * x * p.x % mod);
return *this;
}
ModInt &operator/=(const ModInt &p) {
*this *= p.inverse();
return *this;
}
ModInt operator-() const { return ModInt(-x); }
ModInt operator+(const ModInt &p) const { return ModInt(*this) += p; }
ModInt operator-(const ModInt &p) const { return ModInt(*this) -= p; }
ModInt operator*(const ModInt &p) const { return ModInt(*this) *= p; }
ModInt operator/(const ModInt &p) const { return ModInt(*this) /= p; }
bool operator==(const ModInt &p) const { return x == p.x; }
bool operator!=(const ModInt &p) const { return x != p.x; }
ModInt inverse() const {
int a = x, b = mod, u = 1, v = 0, t;
while (b > 0) {
t = a / b;
swap(a -= t * b, b);
swap(u -= t * v, v);
}
return ModInt(u);
}
ModInt pow(int64_t n) const {
ModInt ret(1), mul(x);
while (n > 0) {
if (n & 1) ret *= mul;
mul *= mul;
n >>= 1;
}
return ret;
}
friend ostream &operator<<(ostream &os, const ModInt &p) { return os << p.x; }
friend istream &operator>>(istream &is, ModInt &a) {
int64_t t;
is >> t;
a = ModInt<mod>(t);
return (is);
}
static int get_mod() { return mod; }
};
using modint = ModInt<MOD>;
using vm = vector<modint>;
constexpr int MAX = 21;
modint dp[MAX][MAX][MAX][MAX][2][2];
modint ep[MAX][MAX][MAX][MAX][2][2];
void solve() {
int N, M;
in(N, M);
vp a(N);
in(a);
dp[0][0][0][0][0][0] = 1;
while (M > 0) {
for (long long acpx = 0; acpx < (long long)(MAX); acpx++)
for (long long acnx = 0; acnx < (long long)(MAX); acnx++)
for (long long acpy = 0; acpy < (long long)(MAX); acpy++)
for (long long acny = 0; acny < (long long)(MAX); acny++)
for (long long afx = 0; afx < (long long)(2); afx++)
for (long long afy = 0; afy < (long long)(2); afy++)
ep[acpx][acnx][acpy][acny][afx][afy] = 0;
for (long long cpx = 0; cpx < (long long)(MAX); cpx++)
for (long long cnx = 0; cnx < (long long)(MAX); cnx++)
for (long long cpy = 0; cpy < (long long)(MAX); cpy++)
for (long long cny = 0; cny < (long long)(MAX); cny++)
for (long long fx = 0; fx < (long long)(2); fx++)
for (long long fy = 0; fy < (long long)(2); fy++) {
modint cur = dp[cpx][cnx][cpy][cny][fx][fy];
if (cur == 0) continue;
for (long long bit = 0; bit < (long long)(1 << N); bit++) {
int dpx = cpx;
int dnx = cnx;
int dpy = cpy;
int dny = cny;
for (long long i = 0; i < (long long)(N); i++) {
if ((bit >> i) & 1) {
dpx += max(0, a[i].first);
dnx -= min(0, a[i].first);
dpy += max(0, a[i].second);
dny -= min(0, a[i].second);
}
}
if ((dpx & 1) != (dnx & 1)) continue;
if ((dpy & 1) != (dny & 1)) continue;
int nfx = (dpx & 1) > (M & 1) ? 1
: (dpx & 1) < (M & 1) ? 0
: fx;
int nfy = (dpy & 1) > (M & 1) ? 1
: (dpy & 1) < (M & 1) ? 0
: fy;
dpx >>= 1;
dnx >>= 1;
dpy >>= 1;
dny >>= 1;
ep[dpx][dnx][dpy][dny][nfx][nfy] += cur;
}
}
swap(dp, ep);
M >>= 1;
}
out(dp[0][0][0][0][0][0] - 1);
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
Country of Metropolia is holding Olympiad of Metrpolises soon. It mean that all jury members of the olympiad should meet together in Metropolis (the capital of the country) for the problem preparation process.
There are n + 1 cities consecutively numbered from 0 to n. City 0 is Metropolis that is the meeting point for all jury members. For each city from 1 to n there is exactly one jury member living there. Olympiad preparation is a long and demanding process that requires k days of work. For all of these k days each of the n jury members should be present in Metropolis to be able to work on problems.
You know the flight schedule in the country (jury members consider themselves important enough to only use flights for transportation). All flights in Metropolia are either going to Metropolis or out of Metropolis. There are no night flights in Metropolia, or in the other words, plane always takes off at the same day it arrives. On his arrival day and departure day jury member is not able to discuss the olympiad. All flights in Megapolia depart and arrive at the same day.
Gather everybody for k days in the capital is a hard objective, doing that while spending the minimum possible money is even harder. Nevertheless, your task is to arrange the cheapest way to bring all of the jury members to Metrpolis, so that they can work together for k days and then send them back to their home cities. Cost of the arrangement is defined as a total cost of tickets for all used flights. It is allowed for jury member to stay in Metropolis for more than k days.
Input
The first line of input contains three integers n, m and k (1 β€ n β€ 105, 0 β€ m β€ 105, 1 β€ k β€ 106).
The i-th of the following m lines contains the description of the i-th flight defined by four integers di, fi, ti and ci (1 β€ di β€ 106, 0 β€ fi β€ n, 0 β€ ti β€ n, 1 β€ ci β€ 106, exactly one of fi and ti equals zero), the day of departure (and arrival), the departure city, the arrival city and the ticket cost.
Output
Output the only integer that is the minimum cost of gathering all jury members in city 0 for k days and then sending them back to their home cities.
If it is impossible to gather everybody in Metropolis for k days and then send them back to their home cities, output "-1" (without the quotes).
Examples
Input
2 6 5
1 1 0 5000
3 2 0 5500
2 2 0 6000
15 0 2 9000
9 0 1 7000
8 0 2 6500
Output
24500
Input
2 4 5
1 2 0 5000
2 1 0 4500
2 1 0 3000
8 0 1 6000
Output
-1
Note
The optimal way to gather everybody in Metropolis in the first sample test is to use flights that take place on days 1, 2, 8 and 9. The only alternative option is to send jury member from second city back home on day 15, that would cost 2500 more.
In the second sample it is impossible to send jury member from city 2 back home from Metropolis.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
const int MAXD = 1000005;
const long long INF = 0x3f3f3f3f3f3f3f3f;
int n, m, k, md;
long long ans = INF;
long long qz[MAXD], MIN[MAXN];
long long zr[MAXD];
struct edge {
int t, u, v, p;
bool operator<(const edge &px) const { return t < px.t; }
} e[MAXN];
long long Read() {
long long x = 0, f = 1;
char c = getchar();
while (c > '9' || c < '0') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x * 10) + (c ^ 48);
c = getchar();
}
return x * f;
}
void Put1(long long x) {
if (x > 9) Put1(x / 10);
putchar(x % 10 ^ 48);
}
void Put(long long x, char c = -1) {
if (x < 0) putchar('-'), x = -x;
Put1(x);
if (c >= 0) putchar(c);
}
template <typename T>
T Max(T x, T y) {
return x > y ? x : y;
}
template <typename T>
T Min(T x, T y) {
return x < y ? x : y;
}
template <typename T>
T Abs(T x) {
return x < 0 ? -x : x;
}
int main() {
n = Read();
m = Read();
k = Read();
for (int i = 1; i <= m; ++i) {
e[i].t = Read();
e[i].u = Read();
e[i].v = Read();
e[i].p = Read();
md = Max(e[i].t, md);
}
sort(e + 1, e + m + 1);
for (int i = 1; i <= n; ++i) MIN[i] = INF;
for (int i = 1; i <= md; ++i) zr[i] = qz[i] = INF;
int zai = 0;
long long tot = 0;
for (int i = 1, j = 1; i <= md && j <= m; ++i) {
while (e[j].u == 0 && j <= m) j++;
if (e[j].t > i) continue;
if (j > m) break;
if (e[j].p < MIN[e[j].u]) {
if (MIN[e[j].u] != INF)
tot -= MIN[e[j].u];
else
zai++;
tot += e[j].p;
MIN[e[j].u] = e[j].p;
if (zai == n) qz[i] = tot;
}
i--;
j++;
}
for (int i = 2; i <= md; ++i) qz[i] = Min(qz[i - 1], qz[i]);
for (int i = 1; i <= n; ++i) MIN[i] = INF;
tot = zai = 0;
for (int i = md, j = m; i >= 1 && j >= 1; --i) {
while (e[j].v == 0 && j >= 1) j--;
if (e[j].t < i) continue;
if (j <= 0) break;
if (e[j].p < MIN[e[j].v]) {
if (MIN[e[j].v] != INF)
tot -= MIN[e[j].v];
else
zai++;
tot += e[j].p;
MIN[e[j].v] = e[j].p;
if (zai == n) zr[i] = tot;
}
i++;
j--;
}
for (int i = md - 1; i >= 1; --i) zr[i] = Min(zr[i + 1], zr[i]);
for (int i = 2; i <= md - k; ++i) ans = Min(ans, qz[i - 1] + zr[i + k]);
if (ans == INF)
printf("-1");
else
Put(ans);
return 0;
}
``` |