text
stringlengths 424
69.5k
|
|---|
### Prompt
Your challenge is to write a cpp solution to the following problem:
You are given three integers A, B and C.
Determine if there exists an equilateral triangle whose sides have lengths A, B and C.
Constraints
* All values in input are integers.
* 1 \leq A,B,C \leq 100
Input
Input is given from Standard Input in the following format:
A B C
Output
If there exists an equilateral triangle whose sides have lengths A, B and C, print `Yes`; otherwise, print `No`.
Examples
Input
2 2 2
Output
Yes
Input
3 4 5
Output
No
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
int a,b,c;
cin >> a >> b >> c;
string s = (a==b && b==c) ? "Yes" : "No";
cout << s;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
You are given a picture consisting of n rows and m columns. Rows are numbered from 1 to n from the top to the bottom, columns are numbered from 1 to m from the left to the right. Each cell is painted either black or white.
You think that this picture is not interesting enough. You consider a picture to be interesting if there is at least one cross in it. A cross is represented by a pair of numbers x and y, where 1 ≤ x ≤ n and 1 ≤ y ≤ m, such that all cells in row x and all cells in column y are painted black.
For examples, each of these pictures contain crosses:
<image>
The fourth picture contains 4 crosses: at (1, 3), (1, 5), (3, 3) and (3, 5).
Following images don't contain crosses:
<image>
You have a brush and a can of black paint, so you can make this picture interesting. Each minute you may choose a white cell and paint it black.
What is the minimum number of minutes you have to spend so the resulting picture contains at least one cross?
You are also asked to answer multiple independent queries.
Input
The first line contains an integer q (1 ≤ q ≤ 5 ⋅ 10^4) — the number of queries.
The first line of each query contains two integers n and m (1 ≤ n, m ≤ 5 ⋅ 10^4, n ⋅ m ≤ 4 ⋅ 10^5) — the number of rows and the number of columns in the picture.
Each of the next n lines contains m characters — '.' if the cell is painted white and '*' if the cell is painted black.
It is guaranteed that ∑ n ≤ 5 ⋅ 10^4 and ∑ n ⋅ m ≤ 4 ⋅ 10^5.
Output
Print q lines, the i-th line should contain a single integer — the answer to the i-th query, which is the minimum number of minutes you have to spend so the resulting picture contains at least one cross.
Example
Input
9
5 5
..*..
..*..
*****
..*..
..*..
3 4
****
.*..
.*..
4 3
***
*..
*..
*..
5 5
*****
*.*.*
*****
..*.*
..***
1 4
****
5 5
.....
..*..
.***.
..*..
.....
5 3
...
.*.
.*.
***
.*.
3 3
.*.
*.*
.*.
4 4
*.**
....
*.**
*.**
Output
0
0
0
0
0
4
1
1
2
Note
The example contains all the pictures from above in the same order.
The first 5 pictures already contain a cross, thus you don't have to paint anything.
You can paint (1, 3), (3, 1), (5, 3) and (3, 5) on the 6-th picture to get a cross in (3, 3). That'll take you 4 minutes.
You can paint (1, 2) on the 7-th picture to get a cross in (4, 2).
You can paint (2, 2) on the 8-th picture to get a cross in (2, 2). You can, for example, paint (1, 3), (3, 1) and (3, 3) to get a cross in (3, 3) but that will take you 3 minutes instead of 1.
There are 9 possible crosses you can get in minimum time on the 9-th picture. One of them is in (1, 1): paint (1, 2) and (2, 1).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int read() {
int f = 1, x = 0;
char c = getchar();
while (c < '0' || '9' < c) {
if (c == '-') f = -1;
c = getchar();
}
while ('0' <= c && c <= '9')
x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
return f * x;
}
string S;
int hang[50000 + 5], lie[50000 + 5];
vector<string> G;
int main() {
int T = read();
while (T--) {
int n = read(), m = read();
for (int i = 0; i < n; i++) {
cin >> S;
for (int j = 0; j < m; j++)
hang[i] += (S[j] == '.'), lie[j] += (S[j] == '.');
G.push_back(S);
}
int ans = 0x3f3f3f3f;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
if (G[i][j] == '.')
ans = min(ans, hang[i] + lie[j] - 1);
else
ans = min(ans, hang[i] + lie[j]);
}
printf("%d\n", ans);
for (int i = 0; i < n; i++) hang[i] = 0;
for (int i = 0; i < m; i++) lie[i] = 0;
G.clear();
}
return 0;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
Igor found out discounts in a shop and decided to buy n items. Discounts at the store will last for a week and Igor knows about each item that its price now is ai, and after a week of discounts its price will be bi.
Not all of sellers are honest, so now some products could be more expensive than after a week of discounts.
Igor decided that buy at least k of items now, but wait with the rest of the week in order to save money as much as possible. Your task is to determine the minimum money that Igor can spend to buy all n items.
Input
In the first line there are two positive integer numbers n and k (1 ≤ n ≤ 2·105, 0 ≤ k ≤ n) — total number of items to buy and minimal number of items Igor wants to by right now.
The second line contains sequence of integers a1, a2, ..., an (1 ≤ ai ≤ 104) — prices of items during discounts (i.e. right now).
The third line contains sequence of integers b1, b2, ..., bn (1 ≤ bi ≤ 104) — prices of items after discounts (i.e. after a week).
Output
Print the minimal amount of money Igor will spend to buy all n items. Remember, he should buy at least k items right now.
Examples
Input
3 1
5 4 6
3 1 5
Output
10
Input
5 3
3 4 7 10 3
4 5 5 12 5
Output
25
Note
In the first example Igor should buy item 3 paying 6. But items 1 and 2 he should buy after a week. He will pay 3 and 1 for them. So in total he will pay 6 + 3 + 1 = 10.
In the second example Igor should buy right now items 1, 2, 4 and 5, paying for them 3, 4, 10 and 3, respectively. Item 3 he should buy after a week of discounts, he will pay 5 for it. In total he will spend 3 + 4 + 10 + 3 + 5 = 25.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int total_items, min_items, ans = 0;
cin >> total_items >> min_items;
int starting[total_items];
int ending[total_items];
for (int i = 0; i < total_items; i++) {
cin >> starting[i];
}
for (int i = 0; i < total_items; i++) {
cin >> ending[i];
}
int total_negative = 0;
pair<int, int> differences[total_items];
for (int i = 0; i < total_items; i++) {
if (starting[i] - ending[i] < 0) total_negative++;
differences[i] = make_pair(starting[i] - ending[i], i);
}
sort(differences, differences + total_items);
int items_to_buy_week_1 = max(min_items, total_negative);
for (int i = 0; i < items_to_buy_week_1; i++) {
ans += starting[differences[i].second];
}
for (int i = items_to_buy_week_1; i < total_items; i++) {
ans += ending[differences[i].second];
}
cout << ans << "\n";
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
We have a directed weighted graph with N vertices. Each vertex has two integers written on it, and the integers written on Vertex i are A_i and B_i.
In this graph, there is an edge from Vertex x to Vertex y for all pairs 1 \leq x,y \leq N, and its weight is {\rm min}(A_x,B_y).
We will consider a directed cycle in this graph that visits every vertex exactly once. Find the minimum total weight of the edges in such a cycle.
Constraints
* 2 \leq N \leq 10^5
* 1 \leq A_i \leq 10^9
* 1 \leq B_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_1 B_1
A_2 B_2
:
A_N B_N
Output
Print the minimum total weight of the edges in such a cycle.
Examples
Input
3
1 5
4 2
6 3
Output
7
Input
4
1 5
2 6
3 7
4 8
Output
10
Input
6
19 92
64 64
78 48
57 33
73 6
95 73
Output
227
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
const int N=1e5+5;
int n,a[N],b[N],p[N],q[N],i,mn;
pair<int,int*>c[N*2];
long long s[N*2],ans=1ll<<60,t,sa;
int main(){
scanf("%d",&n);
for(i=1;i<=n;++i)scanf("%d%d",a+i,b+i),c[i*2-1]=make_pair(a[i],p+i),c[i*2]=make_pair(b[i],q+i),sa+=a[i];
sort(c+1,c+n*2+1);for(i=1;i<=n*2;++i)*c[i].second=i,s[i]=s[i-1]+c[i].first;
ans=min(ans,min(sa,s[n*2]-sa));
for(i=1;i<=n;++i){
int x=p[i],y=q[i];if(x>y)swap(x,y);
if(y<=n)ans=min(ans,s[n]);else if(x<=n-1)ans=min(ans,s[n-1]+c[y].first);
else ans=min(ans,s[n-2]+a[i]+b[i]);
}
printf("%lld\n",ans);
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
Lunar New Year is approaching, and Bob is planning to go for a famous restaurant — "Alice's".
The restaurant "Alice's" serves n kinds of food. The cost for the i-th kind is always c_i. Initially, the restaurant has enough ingredients for serving exactly a_i dishes of the i-th kind. In the New Year's Eve, m customers will visit Alice's one after another and the j-th customer will order d_j dishes of the t_j-th kind of food. The (i + 1)-st customer will only come after the i-th customer is completely served.
Suppose there are r_i dishes of the i-th kind remaining (initially r_i = a_i). When a customer orders 1 dish of the i-th kind, the following principles will be processed.
1. If r_i > 0, the customer will be served exactly 1 dish of the i-th kind. The cost for the dish is c_i. Meanwhile, r_i will be reduced by 1.
2. Otherwise, the customer will be served 1 dish of the cheapest available kind of food if there are any. If there are multiple cheapest kinds of food, the one with the smallest index among the cheapest will be served. The cost will be the cost for the dish served and the remain for the corresponding dish will be reduced by 1.
3. If there are no more dishes at all, the customer will leave angrily. Therefore, no matter how many dishes are served previously, the cost for the customer is 0.
If the customer doesn't leave after the d_j dishes are served, the cost for the customer will be the sum of the cost for these d_j dishes.
Please determine the total cost for each of the m customers.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 10^5), representing the number of different kinds of food and the number of customers, respectively.
The second line contains n positive integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^7), where a_i denotes the initial remain of the i-th kind of dishes.
The third line contains n positive integers c_1, c_2, …, c_n (1 ≤ c_i ≤ 10^6), where c_i denotes the cost of one dish of the i-th kind.
The following m lines describe the orders of the m customers respectively. The j-th line contains two positive integers t_j and d_j (1 ≤ t_j ≤ n, 1 ≤ d_j ≤ 10^7), representing the kind of food and the number of dishes the j-th customer orders, respectively.
Output
Print m lines. In the j-th line print the cost for the j-th customer.
Examples
Input
8 5
8 6 2 1 4 5 7 5
6 3 3 2 6 2 3 2
2 8
1 4
4 7
3 4
6 10
Output
22
24
14
10
39
Input
6 6
6 6 6 6 6 6
6 66 666 6666 66666 666666
1 6
2 6
3 6
4 6
5 6
6 66
Output
36
396
3996
39996
399996
0
Input
6 6
6 6 6 6 6 6
6 66 666 6666 66666 666666
1 6
2 13
3 6
4 11
5 6
6 6
Output
36
11058
99996
4333326
0
0
Note
In the first sample, 5 customers will be served as follows.
1. Customer 1 will be served 6 dishes of the 2-nd kind, 1 dish of the 4-th kind, and 1 dish of the 6-th kind. The cost is 6 ⋅ 3 + 1 ⋅ 2 + 1 ⋅ 2 = 22. The remain of the 8 kinds of food will be \{8, 0, 2, 0, 4, 4, 7, 5\}.
2. Customer 2 will be served 4 dishes of the 1-st kind. The cost is 4 ⋅ 6 = 24. The remain will be \{4, 0, 2, 0, 4, 4, 7, 5\}.
3. Customer 3 will be served 4 dishes of the 6-th kind, 3 dishes of the 8-th kind. The cost is 4 ⋅ 2 + 3 ⋅ 2 = 14. The remain will be \{4, 0, 2, 0, 4, 0, 7, 2\}.
4. Customer 4 will be served 2 dishes of the 3-rd kind, 2 dishes of the 8-th kind. The cost is 2 ⋅ 3 + 2 ⋅ 2 = 10. The remain will be \{4, 0, 0, 0, 4, 0, 7, 0\}.
5. Customer 5 will be served 7 dishes of the 7-th kind, 3 dishes of the 1-st kind. The cost is 7 ⋅ 3 + 3 ⋅ 6 = 39. The remain will be \{1, 0, 0, 0, 4, 0, 0, 0\}.
In the second sample, each customer is served what they order except the last one, who leaves angrily without paying. For example, the second customer is served 6 dishes of the second kind, so the cost is 66 ⋅ 6 = 396.
In the third sample, some customers may not be served what they order. For example, the second customer is served 6 dishes of the second kind, 6 of the third and 1 of the fourth, so the cost is 66 ⋅ 6 + 666 ⋅ 6 + 6666 ⋅ 1 = 11058.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5 + 100000;
int n, m, rem[MAXN];
long long c[MAXN];
bool ok[MAXN];
set<pair<int, int>> s;
long long solve(int k, int num) {
if (num >= rem[k]) {
long long cost = 0LL;
if (ok[k]) {
cost = 1LL * rem[k] * c[k];
num -= rem[k];
rem[k] = 0;
ok[k] = false;
assert(s.find({c[k], k}) != s.end());
s.erase(s.find({c[k], k}));
}
if (num > 0) return cost + solve(s.begin()->second, num);
return cost;
} else {
long long cost = 1LL * num * c[k];
rem[k] -= num;
return cost;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cin >> n >> m;
long long totrem = 0LL;
for (int i = (int)0; i < (int)n; ++i) cin >> rem[i], totrem += rem[i];
for (int i = (int)0; i < (int)n; ++i) cin >> c[i];
for (int i = (int)0; i < (int)n; ++i) {
s.insert({c[i], i});
ok[i] = true;
}
bool can = true;
while (m--) {
int kf, num;
cin >> kf >> num;
if (num > totrem || !can) {
cout << 0 << '\n';
can = false;
} else {
cout << solve(kf - 1, num) << '\n';
totrem -= num;
}
}
return 0;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
There are n players sitting at the card table. Each player has a favorite number. The favorite number of the j-th player is f_j.
There are k ⋅ n cards on the table. Each card contains a single integer: the i-th card contains number c_i. Also, you are given a sequence h_1, h_2, ..., h_k. Its meaning will be explained below.
The players have to distribute all the cards in such a way that each of them will hold exactly k cards. After all the cards are distributed, each player counts the number of cards he has that contains his favorite number. The joy level of a player equals h_t if the player holds t cards containing his favorite number. If a player gets no cards with his favorite number (i.e., t=0), his joy level is 0.
Print the maximum possible total joy levels of the players after the cards are distributed. Note that the sequence h_1, ..., h_k is the same for all the players.
Input
The first line of input contains two integers n and k (1 ≤ n ≤ 500, 1 ≤ k ≤ 10) — the number of players and the number of cards each player will get.
The second line contains k ⋅ n integers c_1, c_2, ..., c_{k ⋅ n} (1 ≤ c_i ≤ 10^5) — the numbers written on the cards.
The third line contains n integers f_1, f_2, ..., f_n (1 ≤ f_j ≤ 10^5) — the favorite numbers of the players.
The fourth line contains k integers h_1, h_2, ..., h_k (1 ≤ h_t ≤ 10^5), where h_t is the joy level of a player if he gets exactly t cards with his favorite number written on them. It is guaranteed that the condition h_{t - 1} < h_t holds for each t ∈ [2..k].
Output
Print one integer — the maximum possible total joy levels of the players among all possible card distributions.
Examples
Input
4 3
1 3 2 8 5 5 8 2 2 8 5 2
1 2 2 5
2 6 7
Output
21
Input
3 3
9 9 9 9 9 9 9 9 9
1 2 3
1 2 3
Output
0
Note
In the first example, one possible optimal card distribution is the following:
* Player 1 gets cards with numbers [1, 3, 8];
* Player 2 gets cards with numbers [2, 2, 8];
* Player 3 gets cards with numbers [2, 2, 8];
* Player 4 gets cards with numbers [5, 5, 5].
Thus, the answer is 2 + 6 + 6 + 7 = 21.
In the second example, no player can get a card with his favorite number. Thus, the answer is 0.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long int mod = 1000000007;
long long int freqC[100001];
long long int freqF[100001];
long long int h[11];
long long int DP[5000][501];
int main() {
long long int i, j, k, l, m, n, p, q, x, y, z, a, b, c, d, e, f, r;
scanf("%lld", &n);
scanf("%lld", &k);
for (i = 0; i < k * n; i++) {
scanf("%lld", &c);
freqC[c]++;
}
for (i = 0; i < n; i++) {
scanf("%lld", &f);
freqF[f]++;
}
for (i = 1; i <= k; i++) {
scanf("%lld", &h[i]);
}
for (j = 1; j <= n; j++) {
for (i = 1; i < k * n; i++) {
if (i >= j * k) {
DP[i][j] = h[k] * j;
} else {
for (p = 0; p <= min(k, i); p++) {
DP[i][j] = max(DP[i][j], h[p] + DP[i - p][j - 1]);
}
}
}
}
a = 0;
for (i = 0; i <= 100000; i++) {
if (freqC[i] >= freqF[i] * k) {
a += h[k] * freqF[i];
} else {
a += DP[freqC[i]][freqF[i]];
}
}
printf("%lld\n", a);
return 0;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
Malek has recently found a treasure map. While he was looking for a treasure he found a locked door. There was a string s written on the door consisting of characters '(', ')' and '#'. Below there was a manual on how to open the door. After spending a long time Malek managed to decode the manual and found out that the goal is to replace each '#' with one or more ')' characters so that the final string becomes beautiful.
Below there was also written that a string is called beautiful if for each i (1 ≤ i ≤ |s|) there are no more ')' characters than '(' characters among the first i characters of s and also the total number of '(' characters is equal to the total number of ')' characters.
Help Malek open the door by telling him for each '#' character how many ')' characters he must replace it with.
Input
The first line of the input contains a string s (1 ≤ |s| ≤ 105). Each character of this string is one of the characters '(', ')' or '#'. It is guaranteed that s contains at least one '#' character.
Output
If there is no way of replacing '#' characters which leads to a beautiful string print - 1. Otherwise for each character '#' print a separate line containing a positive integer, the number of ')' characters this character must be replaced with.
If there are several possible answers, you may output any of them.
Examples
Input
(((#)((#)
Output
1
2
Input
()((#((#(#()
Output
2
2
1
Input
#
Output
-1
Input
(#)
Output
-1
Note
|s| denotes the length of the string s.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int arr[1000010];
int brr[1000010];
stack<int> st;
int main() {
int prev;
int cnt = 0;
string s;
cin >> s;
int lst = -1;
int l = s.length();
bool b = true;
for (int i = 0; i < l; i++) {
if (s[i] == '(') {
st.push(i);
cnt++;
}
if (s[i] == ')') {
cnt--;
if (cnt < 0) {
b = false;
break;
} else
st.pop();
}
if (s[i] == '#') {
cnt--;
if (cnt < 0) {
b = false;
break;
} else {
st.pop();
arr[i] = 1;
brr[i] = 1;
}
lst = max(lst, i);
}
}
while (!st.empty() and b) {
int tp = st.top();
if (tp > lst) {
b = false;
break;
} else {
cnt--;
st.pop();
brr[lst]++;
}
}
if (!b || (cnt != 0)) {
cout << -1 << endl;
return 0;
}
for (int i = 0; i < l; i++) {
if (arr[i] == 1) {
cout << brr[i] << endl;
}
}
return 0;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
Professor Matsuzaki is a scientist studying the truth of the universe. Life, the universe, all the answers are said to be 42, but Professor Matsuzaki thinks that this alone is not enough to elucidate the truth of the universe. Professor Matsuzaki believes that the truth of the universe is represented by a function consisting of two parameters, and 42 is just one of them.
The function M (N, P) defined by Professor Matsuzaki selects two prime numbers larger than N (the same number can be two) and sums them, in order from the smallest number. Represents the number that appears in the Pth position when arranged. Here, there are numbers that can be represented by two or more sums, but such numbers are arranged in the same number as the number of combinations of sums.
As an example, consider the case of N = 0. In this case, two are selected from all the prime numbers and summed. Considering the smallest number among such sums, it is permissible to select the same number twice, which shows that 2 + 2 = 4. That is, M (0, 1) = 4. The next smallest number is 2 + 3 = 5, so M (0, 2) = 5. Considering in the same way, it can be seen that the sums are arranged as 4, 5, 6, 7, 8, 9, 10, 10, 12, 13, 14, 14, 16, .... That is, for example, M (0, 9) = 12.
Considering the case of N = 10 in the same way, in this case, two prime numbers greater than 10 {11, 13, 17, 19, ...} are selected, and the sums obtained are arranged in ascending order. And 22, 24, 26, 28, 30, 30, 32, ...
Your job is to write a program that calculates M (N, P) given N and P.
Input
The input consists of multiple datasets. The dataset is one line, given two integers N (0 ≤ N ≤ 100,000) and P (1 ≤ P ≤ 100) separated by a single space.
The end of the input is indicated by a single line containing two blank-separated -1s.
Output
For each dataset, output the value of M (N, P) on one line. The output must not contain extra blanks or line breaks.
Sample Input
0 55
0 1
0 2
0 3
10 1
10 2
10 3
10 4
10 5
10 6
11 1
11 2
11 3
100000 100
-1 -1
Output for the Sample Input
42
Four
Five
6
twenty two
twenty four
26
28
30
30
26
30
32
200274
Example
Input
0 55
0 1
0 2
0 3
10 1
10 2
10 3
10 4
10 5
10 6
11 1
11 2
11 3
100000 100
-1 -1
Output
42
4
5
6
22
24
26
28
30
30
26
30
32
200274
### Response
```cpp
#include <iostream>
#include <cmath>
#include <vector>
#include <algorithm>
using namespace std;
const int N=200000;
int main(void){
vector<bool> isprime(N+1);
for(int i=0;i<isprime.size();i++) isprime[i]=true;
int upto = (int)sqrt(isprime.size());
isprime[0]=isprime[1]=false;
for(int i=2;i<=upto;++i){
if(isprime[i]){//消されてなければその倍数を消す
for(int j=2;i*j<isprime.size();++j) isprime[i*j] = false;
}
}
int n,p;
while(cin>>n>>p,!(n==-1&&p==-1)){
vector<int> tmp,ans;
for(int i=n+1,count=0;count<100;++i){
if(isprime[i]){
tmp.push_back(i);
++count;
}
}
for(int i=0;i<100;++i){
for(int j=i;j<100;++j){
ans.push_back(tmp[i]+tmp[j]);
}
}
sort(ans.begin(),ans.end());
cout<<ans[p-1]<<endl;
}
return 0;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
Let's define a balanced multiset the following way. Write down the sum of all elements of the multiset in its decimal representation. For each position of that number check if the multiset includes at least one element such that the digit of the element and the digit of the sum at that position are the same. If that holds for every position, then the multiset is balanced. Otherwise it's unbalanced.
For example, multiset \{20, 300, 10001\} is balanced and multiset \{20, 310, 10001\} is unbalanced:
<image>
The red digits mark the elements and the positions for which these elements have the same digit as the sum. The sum of the first multiset is 10321, every position has the digit required. The sum of the second multiset is 10331 and the second-to-last digit doesn't appear in any number, thus making the multiset unbalanced.
You are given an array a_1, a_2, ..., a_n, consisting of n integers.
You are asked to perform some queries on it. The queries can be of two types:
* 1~i~x — replace a_i with the value x;
* 2~l~r — find the unbalanced subset of the multiset of the numbers a_l, a_{l + 1}, ..., a_r with the minimum sum, or report that no unbalanced subset exists.
Note that the empty multiset is balanced.
For each query of the second type print the lowest sum of the unbalanced subset. Print -1 if no unbalanced subset exists.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 2 ⋅ 10^5) — the number of elements in the array and the number of queries, respectively.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i < 10^9).
Each of the following m lines contains a query of one of two types:
* 1~i~x (1 ≤ i ≤ n, 1 ≤ x < 10^9) — replace a_i with the value x;
* 2~l~r (1 ≤ l ≤ r ≤ n) — find the unbalanced subset of the multiset of the numbers a_l, a_{l + 1}, ..., a_r with the lowest sum, or report that no unbalanced subset exists.
It is guaranteed that there is at least one query of the second type.
Output
For each query of the second type print the lowest sum of the unbalanced subset. Print -1 if no unbalanced subset exists.
Example
Input
4 5
300 10001 20 20
2 1 3
1 1 310
2 1 3
2 3 3
2 3 4
Output
-1
330
-1
40
Note
All the subsets of multiset \{20, 300, 10001\} are balanced, thus the answer is -1.
The possible unbalanced subsets in the third query are \{20, 310\} and \{20, 310, 10001\}. The lowest sum one is \{20, 310\}. Note that you are asked to choose a subset, not a subsegment, thus the chosen elements might not be adjancent in the array.
The fourth query includes only the empty subset and subset \{20\}. Both of them are balanced.
The last query includes the empty subset and the subsets \{20\}, \{20\} and \{20, 20\}. Only \{20, 20\} is unbalanced, its sum is 40. Note that you are asked to choose a multiset, thus it might include equal elements.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
template <typename T>
using matrix = vector<vector<T>>;
constexpr int INF = (int)2e9 + 7;
constexpr int MAXN = (int)2e5 + 1;
constexpr int MOD = (int)2e9 + 7;
constexpr double EPS = 1e-9;
struct st_t_ {
pii a[10];
};
using st_t = st_t_;
using st_val_t = int;
st_val_t a[MAXN];
st_t st[MAXN * 4];
void st_put(int v, st_val_t val) {
int t = val;
for (int i = 0; i < 10; ++i) {
st[v].a[i] = {INF, INF};
if (t % 10 != 0) st[v].a[i].first = val;
t /= 10;
}
}
void st_push(int v) {}
st_t st_combine(st_t a, st_t b) {
st_t res;
for (int i = 0; i < 10; ++i) {
int t[] = {a.a[i].first, a.a[i].second, b.a[i].first, b.a[i].second};
sort(t, t + 4);
res.a[i] = {t[0], t[1]};
}
return res;
}
void st_build(int v, int tl, int tr) {
if (tl == tr) {
st_put(v, a[tl]);
} else {
int tm = (tl + tr) / 2;
st_build(2 * v, tl, tm);
st_build(2 * v + 1, tm + 1, tr);
st[v] = st_combine(st[2 * v], st[2 * v + 1]);
}
}
void st_update(int v, int tl, int tr, int x, st_val_t val) {
if (tl == tr) {
st_put(v, val);
} else {
st_push(v);
int tm = (tl + tr) / 2;
if (x <= tm)
st_update(2 * v, tl, tm, x, val);
else
st_update(2 * v + 1, tm + 1, tr, x, val);
st[v] = st_combine(st[2 * v], st[2 * v + 1]);
}
}
st_t st_query(int v, int tl, int tr, int l, int r) {
if (l <= tl && tr <= r) return st[v];
st_push(v);
int tm = (tl + tr) / 2;
if (r <= tm) return st_query(v * 2, tl, tm, l, r);
if (l > tm) return st_query(v * 2 + 1, tm + 1, tr, l, r);
return st_combine(st_query(v * 2, tl, tm, l, tm),
st_query(v * 2 + 1, tm + 1, tr, tm + 1, r));
}
class EZaprosiSummi {
public:
void solve(std::istream &in, std::ostream &out) {
int n, m;
in >> n >> m;
for (int i = 1; i <= n; ++i) {
in >> a[i];
}
st_build(1, 1, n);
for (int i = 0; i < m; ++i) {
int t, l, r;
in >> t >> l >> r;
if (t == 1) {
st_update(1, 1, n, l, r);
} else {
auto t = st_query(1, 1, n, l, r);
int res = INF;
for (int j = 0; j < 10; ++j) {
if (t.a[j].first < INF && t.a[j].second < INF)
res = min(res, t.a[j].first + t.a[j].second);
}
out << (res == INF ? -1 : res) << endl;
}
}
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cout << fixed << setprecision(9);
EZaprosiSummi solver;
std::istream &in(std::cin);
std::ostream &out(std::cout);
solver.solve(in, out);
return 0;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
Tattah's youngest brother, Tuftuf, is new to programming.
Since his older brother is such a good programmer, his biggest dream is to outshine him. Tuftuf is a student at the German University in Cairo (GUC) where he learns to write programs in Gava.
Today, Tuftuf was introduced to Gava's unsigned integer datatypes. Gava has n unsigned integer datatypes of sizes (in bits) a1, a2, ... an. The i-th datatype have size ai bits, so it can represent every integer between 0 and 2ai - 1 inclusive.
Tuftuf is thinking of learning a better programming language. If there exists an integer x, such that x fits in some type i (in ai bits) and x·x does not fit in some other type j (in aj bits) where ai < aj, then Tuftuf will stop using Gava.
Your task is to determine Tuftuf's destiny.
Input
The first line contains integer n (2 ≤ n ≤ 105) — the number of Gava's unsigned integer datatypes' sizes. The second line contains a single-space-separated list of n integers (1 ≤ ai ≤ 109) — sizes of datatypes in bits. Some datatypes may have equal sizes.
Output
Print "YES" if Tuftuf will stop using Gava, and "NO" otherwise.
Examples
Input
3
64 16 32
Output
NO
Input
4
4 2 1 3
Output
YES
Note
In the second example, x = 7 (1112) fits in 3 bits, but x2 = 49 (1100012) does not fit in 4 bits.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using lli = long long int;
const int MOD = 1000000007;
const int MOD1 = 998244353;
const int maxn = 100010;
const int lim = (int)1e9;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n = 0, x = 0;
cin >> n;
vector<int> a(n);
for (auto &i : a) cin >> i;
sort(a.begin(), a.end());
for (int i = 0; i + 1 < n; ++i) {
if (a[i] < a[i + 1] && 2ll * a[i] > a[i + 1]) {
cout << "YES";
return 0;
}
}
cout << "NO";
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
There are many caves deep in mountains found in the countryside. In legend, each cave has a treasure hidden within the farthest room from the cave's entrance. The Shogun has ordered his Samurais to explore these caves with Karakuri dolls (robots) and to find all treasures. These robots move in the caves and log relative distances and directions between rooms.
Each room in a cave is mapped to a point on an integer grid (x, y >= 0). For each cave, the robot always starts from its entrance, runs along the grid and returns to the entrance (which also serves as the exit). The treasure in each cave is hidden in the farthest room from the entrance, using Euclid distance for measurement, i.e. the distance of the room at point (x, y) from the entrance (0, 0) is defined as the square root of (x*x+y*y). If more than one room has the same farthest distance from the entrance, the treasure is hidden in the room having the greatest value of x. While the robot explores a cave, it records how it has moved. Each time it takes a new direction at a room, it notes the difference (dx, dy) from the last time it changed its direction. For example, suppose the robot is currently in the room at point (2, 4). If it moves to room (6, 4), the robot records (4, 0), i.e. dx=6-2 and dy=4-4. The first data is defined as the difference from the entrance. The following figure shows rooms in the first cave of the Sample Input. In the figure, the farthest room is the square root of 61 distant from the entrance.
<image>
Based on the records that the robots bring back, your job is to determine the rooms where treasures are hidden.
Input
In the first line of the input, an integer N showing the number of caves in the input is given. Integers dxi and dyi are i-th data showing the differences between rooms. Note that since the robot moves along the grid, either dxi or dyi is zero. An integer pair dxi = dyi = 0 signals the end of one cave's data which means the robot finished the exploration for the cave and returned back to the entrance. The coordinates are limited to (0,0)-(1000,1000).
Output
Print the position (x, y) of the treasure room on a line for each cave.
Example
Input
3
1 0
0 1
-1 0
1 0
0 5
-1 0
0 -1
5 0
0 1
0 -1
1 0
0 -4
-3 0
0 3
2 0
0 -2
-1 0
0 1
0 -1
1 0
0 2
-2 0
0 -3
3 0
0 4
-4 0
0 -5
-2 0
0 0
1 0
-1 0
0 0
2 0
0 1
-1 0
0 1
-1 0
0 -2
0 0
Output
6 5
1 0
2 1
### Response
```cpp
#include <stdio.h>
#include <cmath>
#include <algorithm>
#include <cfloat>
#include <stack>
#include <queue>
#include <vector>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;
int calcDist(int x,int y){
return x*x + y*y;
}
void func(){
int ans_x = 0,ans_y = 0,tmp_x=0,tmp_y=0,dx,dy,maximum = 0,maximum_x,tmp_dist;
while(true){
scanf("%d %d",&dx,&dy);
if(dx == 0 && dy == 0)break;
tmp_x += dx;
tmp_y += dy;
tmp_dist = calcDist(tmp_x,tmp_y);
if(tmp_dist > maximum){
maximum = tmp_dist;
maximum_x = tmp_x;
ans_x = tmp_x;
ans_y = tmp_y;
}else if(tmp_dist == maximum && maximum_x < tmp_x){
maximum_x = tmp_x;
ans_x = tmp_x;
ans_y = tmp_y;
}
}
printf("%d %d\n",ans_x,ans_y);
}
int main(){
int N;
scanf("%d",&N);
for(int i = 0; i < N; i++)func();
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
Filled with optimism, Hyunuk will host a conference about how great this new year will be!
The conference will have n lectures. Hyunuk has two candidate venues a and b. For each of the n lectures, the speaker specified two time intervals [sa_i, ea_i] (sa_i ≤ ea_i) and [sb_i, eb_i] (sb_i ≤ eb_i). If the conference is situated in venue a, the lecture will be held from sa_i to ea_i, and if the conference is situated in venue b, the lecture will be held from sb_i to eb_i. Hyunuk will choose one of these venues and all lectures will be held at that venue.
Two lectures are said to overlap if they share any point in time in common. Formally, a lecture held in interval [x, y] overlaps with a lecture held in interval [u, v] if and only if max(x, u) ≤ min(y, v).
We say that a participant can attend a subset s of the lectures if the lectures in s do not pairwise overlap (i.e. no two lectures overlap). Note that the possibility of attending may depend on whether Hyunuk selected venue a or venue b to hold the conference.
A subset of lectures s is said to be venue-sensitive if, for one of the venues, the participant can attend s, but for the other venue, the participant cannot attend s.
A venue-sensitive set is problematic for a participant who is interested in attending the lectures in s because the participant cannot be sure whether the lecture times will overlap. Hyunuk will be happy if and only if there are no venue-sensitive sets. Determine whether Hyunuk will be happy.
Input
The first line contains an integer n (1 ≤ n ≤ 100 000), the number of lectures held in the conference.
Each of the next n lines contains four integers sa_i, ea_i, sb_i, eb_i (1 ≤ sa_i, ea_i, sb_i, eb_i ≤ 10^9, sa_i ≤ ea_i, sb_i ≤ eb_i).
Output
Print "YES" if Hyunuk will be happy. Print "NO" otherwise.
You can print each letter in any case (upper or lower).
Examples
Input
2
1 2 3 6
3 4 7 8
Output
YES
Input
3
1 3 2 4
4 5 6 7
3 4 5 5
Output
NO
Input
6
1 5 2 9
2 4 5 8
3 6 7 11
7 10 12 16
8 11 13 17
9 12 14 18
Output
YES
Note
In second example, lecture set \{1, 3\} is venue-sensitive. Because participant can't attend this lectures in venue a, but can attend in venue b.
In first and third example, venue-sensitive set does not exist.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct info {
int l1, r1, l2, r2;
info(int _l1, int _r1, int _l2, int _r2) {
l1 = _l1;
r1 = _r1;
l2 = _l2;
r2 = _r2;
}
};
const int maxn = 5e5 + 10;
int tree[4 * maxn], lazy[4 * maxn];
vector<pair<int, int> > agrega[maxn], quita[maxn];
vector<pair<int, int> > agrega2[maxn], quita2[maxn];
vector<info> A;
int N;
void build() {
for (int i = 0; i < 4 * maxn; i++) {
tree[i] = lazy[i] = 0;
}
}
void update(int node, int start, int end, int l, int r, int val) {
if (lazy[node] != 0) {
tree[node] += lazy[node];
if (start != end) {
lazy[node * 2] += lazy[node];
lazy[node * 2 + 1] += lazy[node];
}
lazy[node] = 0;
}
if (start > end || start > r || end < l) return;
if (start >= l && end <= r) {
tree[node] += val;
if (start != end) {
lazy[node * 2] += val;
lazy[node * 2 + 1] += val;
}
return;
}
int mid = (start + end) / 2;
update(node * 2, start, mid, l, r, val);
update(node * 2 + 1, mid + 1, end, l, r, val);
tree[node] = max(tree[node * 2], tree[node * 2 + 1]);
}
int query(int node, int start, int end, int l, int r) {
if (start > end || start > r || end < l) return 0;
if (lazy[node] != 0) {
tree[node] += lazy[node];
if (start != end) {
lazy[node * 2] += lazy[node];
lazy[node * 2 + 1] += lazy[node];
}
lazy[node] = 0;
}
if (start >= l && end <= r) return tree[node];
int mid = (start + end) / 2;
int p1 = query(node * 2, start, mid, l, r);
int p2 = query(node * 2 + 1, mid + 1, end, l, r);
return max(p1, p2);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> N;
vector<int> unicos, diffs;
;
for (int i = 0; i < N; i++) {
int l1, r1, l2, r2;
cin >> l1 >> r1 >> l2 >> r2;
unicos.push_back(l1);
unicos.push_back(r1);
unicos.push_back(l2);
unicos.push_back(r2);
A.push_back(info(l1, r1, l2, r2));
}
sort((unicos).begin(), (unicos).end());
unicos.erase(unique((unicos).begin(), (unicos).end()), unicos.end());
for (int i = 0; i < N; i++) {
A[i].l1 =
lower_bound((unicos).begin(), (unicos).end(), A[i].l1) - unicos.begin();
A[i].r1 =
lower_bound((unicos).begin(), (unicos).end(), A[i].r1) - unicos.begin();
A[i].l2 =
lower_bound((unicos).begin(), (unicos).end(), A[i].l2) - unicos.begin();
A[i].r2 =
lower_bound((unicos).begin(), (unicos).end(), A[i].r2) - unicos.begin();
diffs.push_back(A[i].l1);
diffs.push_back(A[i].r1);
diffs.push_back(A[i].l2);
diffs.push_back(A[i].r2);
agrega[A[i].l1].push_back({A[i].l2, A[i].r2});
quita[A[i].r1 + 1].push_back({A[i].l2, A[i].r2});
agrega2[A[i].l2].push_back({A[i].l1, A[i].r1});
quita2[A[i].r2 + 1].push_back({A[i].l1, A[i].r1});
}
sort((diffs).begin(), (diffs).end());
diffs.erase(unique((diffs).begin(), (diffs).end()), diffs.end());
build();
int cnt = 0;
int fin = diffs.back() + 1;
for (int i = 0; i < fin + 1; i++) {
for (auto &x : quita[i]) {
cnt--;
update(1, 0, fin, x.first, x.second, -1);
}
for (auto &x : agrega[i]) {
if (cnt) {
int cntAnt = query(1, 0, fin, x.first, x.second);
if (cntAnt != cnt) {
cout << "NO\n";
;
return 0;
}
}
cnt++;
update(1, 0, fin, x.first, x.second, 1);
}
}
build();
cnt = 0;
for (int i = 0; i < fin + 1; i++) {
for (auto &x : quita2[i]) {
cnt--;
update(1, 0, fin, x.first, x.second, -1);
}
for (auto &x : agrega2[i]) {
if (cnt) {
int cntAnt = query(1, 0, fin, x.first, x.second);
if (cntAnt != cnt) {
cout << "NO\n";
;
return 0;
}
}
cnt++;
update(1, 0, fin, x.first, x.second, 1);
}
}
cout << "YES\n";
;
return 0;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
You are given n arrays a_1, a_2, ..., a_n; each array consists of exactly m integers. We denote the y-th element of the x-th array as a_{x, y}.
You have to choose two arrays a_i and a_j (1 ≤ i, j ≤ n, it is possible that i = j). After that, you will obtain a new array b consisting of m integers, such that for every k ∈ [1, m] b_k = max(a_{i, k}, a_{j, k}).
Your goal is to choose i and j so that the value of min _{k = 1}^{m} b_k is maximum possible.
Input
The first line contains two integers n and m (1 ≤ n ≤ 3 ⋅ 10^5, 1 ≤ m ≤ 8) — the number of arrays and the number of elements in each array, respectively.
Then n lines follow, the x-th line contains the array a_x represented by m integers a_{x, 1}, a_{x, 2}, ..., a_{x, m} (0 ≤ a_{x, y} ≤ 10^9).
Output
Print two integers i and j (1 ≤ i, j ≤ n, it is possible that i = j) — the indices of the two arrays you have to choose so that the value of min _{k = 1}^{m} b_k is maximum possible. If there are multiple answers, print any of them.
Example
Input
6 5
5 0 3 1 2
1 8 9 1 3
1 2 3 4 5
9 1 0 3 7
2 3 0 6 3
6 4 1 7 0
Output
1 5
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (int)3e5;
int n, m;
long long val[(1 << 8) + 5], koji[(1 << 8) + 5];
long long sol = -1;
pair<int, int> res = make_pair(1, 1);
vector<int> v;
const long long inf = (long long)1e9 + 5;
void solve(long long mask, long long first, long long sad, int idx) {
if (first == m) {
sad = min(sad, val[mask]);
if (koji[mask] && sad > sol) {
sol = sad;
res = make_pair(idx, koji[mask]);
}
return;
}
solve(mask, first + 1, min(sad, (long long)v[first]), idx);
solve(mask | (1 << first), first + 1, sad, idx);
}
void procesiraj(long long mask, long long first, long long sad, int idx) {
if (first == m) {
if (sad >= val[mask]) {
val[mask] = sad;
koji[mask] = idx;
}
return;
}
procesiraj(mask, first + 1, sad, idx);
procesiraj(mask | (1 << first), first + 1, min(sad, (long long)v[first]),
idx);
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; ++i) {
v.clear();
for (int j = 0; j < m; ++j) {
int first;
scanf("%d", &first);
v.push_back(first);
}
solve(0, 0, inf, i);
procesiraj(0, 0, inf, i);
}
printf("%d %d", res.first, res.second);
return 0;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
Enough is enough. Too many times it happened that Vasya forgot to dispose of garbage and his apartment stank afterwards. Now he wants to create a garbage disposal plan and stick to it.
For each of next n days Vasya knows a_i — number of units of garbage he will produce on the i-th day. Each unit of garbage must be disposed of either on the day it was produced or on the next day. Vasya disposes of garbage by putting it inside a bag and dropping the bag into a garbage container. Each bag can contain up to k units of garbage. It is allowed to compose and drop multiple bags into a garbage container in a single day.
Being economical, Vasya wants to use as few bags as possible. You are to compute the minimum number of bags Vasya needs to dispose of all of his garbage for the given n days. No garbage should be left after the n-th day.
Input
The first line of the input contains two integers n and k (1 ≤ n ≤ 2⋅10^5, 1 ≤ k ≤ 10^9) — number of days to consider and bag's capacity. The second line contains n space separated integers a_i (0 ≤ a_i ≤ 10^9) — the number of units of garbage produced on the i-th day.
Output
Output a single integer — the minimum number of bags Vasya needs to dispose of all garbage. Each unit of garbage should be disposed on the day it was produced or on the next day. No garbage can be left after the n-th day. In a day it is allowed to compose and drop multiple bags.
Examples
Input
3 2
3 2 1
Output
3
Input
5 1
1000000000 1000000000 1000000000 1000000000 1000000000
Output
5000000000
Input
3 2
1 0 1
Output
2
Input
4 4
2 8 4 1
Output
4
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, k;
cin >> n >> k;
vector<int> vec;
int v;
for (int i = 0; i < n; i++) {
cin >> v;
vec.push_back(v);
}
long long ans = 0, rem = 0;
for (int i = 0; i < n; i++) {
vec[i] -= rem;
if (vec[i] < 0) {
rem = 0;
continue;
}
int req = vec[i] / k + !!(vec[i] % k);
if (vec[i] % k)
rem = k - (vec[i] % k);
else
rem = 0;
ans += req;
}
cout << ans << '\n';
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
You are given a directed graph of n vertices and m edges. Vertices are numbered from 1 to n. There is a token in vertex 1.
The following actions are allowed:
* Token movement. To move the token from vertex u to vertex v if there is an edge u → v in the graph. This action takes 1 second.
* Graph transposition. To transpose all the edges in the graph: replace each edge u → v by an edge v → u. This action takes increasingly more time: k-th transposition takes 2^{k-1} seconds, i.e. the first transposition takes 1 second, the second one takes 2 seconds, the third one takes 4 seconds, and so on.
The goal is to move the token from vertex 1 to vertex n in the shortest possible time. Print this time modulo 998 244 353.
Input
The first line of input contains two integers n, m (1 ≤ n, m ≤ 200 000).
The next m lines contain two integers each: u, v (1 ≤ u, v ≤ n; u ≠ v), which represent the edges of the graph. It is guaranteed that all ordered pairs (u, v) are distinct.
It is guaranteed that it is possible to move the token from vertex 1 to vertex n using the actions above.
Output
Print one integer: the minimum required time modulo 998 244 353.
Examples
Input
4 4
1 2
2 3
3 4
4 1
Output
2
Input
4 3
2 1
2 3
4 3
Output
10
Note
The first example can be solved by transposing the graph and moving the token to vertex 4, taking 2 seconds.
The best way to solve the second example is the following: transpose the graph, move the token to vertex 2, transpose the graph again, move the token to vertex 3, transpose the graph once more and move the token to vertex 4.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
int mul(int a, int b) { return (long long)a * b % mod; }
int add(int a, int b) {
int res = (long long)a + b;
if (res < 0)
res += mod;
else if (res > mod)
res -= mod;
return res;
}
int bpow(int x, int p) {
int res = 1;
while (p) {
if (p & 1) res = mul(res, x);
p >>= 1;
if (p) x = mul(x, x);
}
return res;
}
void solve() {
int n, m;
cin >> n >> m;
vector<vector<pair<int, int>>> g(25 * n);
vector<vector<pair<int, int>>> g2(2 * n);
for (int i = 0; i < m; i++) {
int f, t;
cin >> f >> t;
f--;
t--;
for (int j = 0; j < 25; j++) {
if (j % 2)
g[t + j * n].push_back({f + j * n, 1});
else
g[f + j * n].push_back({t + j * n, 1});
}
g2[f].push_back({t, 0});
g2[t + n].push_back({f + n, 0});
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < 24; j++) {
g[i + j * n].push_back({i + (j + 1) * n, 1 << j});
}
g2[i].push_back({i + n, 1});
g2[i + n].push_back({i, 1});
}
priority_queue<pair<long long, int>> q;
vector<long long> used(25 * n, -1);
q.push({0, 0});
while (q.size()) {
auto v = q.top();
q.pop();
v.first *= -1;
if (used[v.second] != -1) continue;
used[v.second] = v.first;
for (auto to : g[v.second]) {
if (used[to.first] == -1) q.push({-(to.second + v.first), to.first});
}
}
long long ans = 1e18;
for (int i = 0; i < 25; i++) {
if (used[n - 1 + i * n] != -1) ans = min(ans, used[n - 1 + i * n]);
}
if (ans == 1e18) ans = -1;
if (ans != -1) {
cout << ans % mod;
return;
}
priority_queue<pair<pair<int, int>, int>> q2;
vector<pair<int, int>> used2(2 * n, {-1, -1});
q2.push({{0, 0}, 0});
while (q2.size()) {
auto v = q2.top();
q2.pop();
v.first.first *= -1;
v.first.second *= -1;
if (used2[v.second] != make_pair(-1, -1)) {
continue;
}
used2[v.second] = v.first;
for (auto to : g2[v.second]) {
if (to.second == 0 && used2[to.first] == make_pair(-1, -1)) {
q2.push({{-v.first.first, -v.first.second - 1}, to.first});
} else if (used2[to.first] == make_pair(-1, -1)) {
q2.push({{-v.first.first - 1, -v.first.second}, to.first});
}
}
}
pair<int, int> ans2 = min(used2[n - 1], used2[2 * n - 1]);
cout << add(ans2.second, add(bpow(2, ans2.first), -1));
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int q = 1;
for (; q > 0; q--) {
solve();
cout << endl;
}
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
Robbers, who attacked the Gerda's cab, are very successful in covering from the kingdom police. To make the goal of catching them even harder, they use their own watches.
First, as they know that kingdom police is bad at math, robbers use the positional numeral system with base 7. Second, they divide one day in n hours, and each hour in m minutes. Personal watches of each robber are divided in two parts: first of them has the smallest possible number of places that is necessary to display any integer from 0 to n - 1, while the second has the smallest possible number of places that is necessary to display any integer from 0 to m - 1. Finally, if some value of hours or minutes can be displayed using less number of places in base 7 than this watches have, the required number of zeroes is added at the beginning of notation.
Note that to display number 0 section of the watches is required to have at least one place.
Little robber wants to know the number of moments of time (particular values of hours and minutes), such that all digits displayed on the watches are distinct. Help her calculate this number.
Input
The first line of the input contains two integers, given in the decimal notation, n and m (1 ≤ n, m ≤ 109) — the number of hours in one day and the number of minutes in one hour, respectively.
Output
Print one integer in decimal notation — the number of different pairs of hour and minute, such that all digits displayed on the watches are distinct.
Examples
Input
2 3
Output
4
Input
8 2
Output
5
Note
In the first sample, possible pairs are: (0: 1), (0: 2), (1: 0), (1: 2).
In the second sample, possible pairs are: (02: 1), (03: 1), (04: 1), (05: 1), (06: 1).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T>
bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
const int mod = 1000000007, MAX = 205, INF = 1 << 30;
int main() {
std::ifstream in("text.txt");
std::cin.rdbuf(in.rdbuf());
cin.tie(0);
ios::sync_with_stdio(false);
int N, M;
cin >> N >> M;
vector<int> X = {1};
while (int(X.size()) <= 7) X.push_back(X.back() * 7);
X.push_back(INF);
int cnt1 = 0, cnt2 = 0;
for (int i = 1; i < int(X.size()); i++) {
if (N <= X[i]) {
cnt1 = i;
break;
}
}
for (int i = 1; i < int(X.size()); i++) {
if (M <= X[i]) {
cnt2 = i;
break;
}
}
if (cnt1 + cnt2 >= 8) {
cout << 0 << endl;
return 0;
}
vector<int> id(7);
iota((id).begin(), (id).end(), 0);
set<pair<int, int>> SE;
do {
int a = 0, b = 0;
for (int i = 0; i < cnt1; i++) {
a *= 7;
a += id[i];
}
for (int i = 0; i < cnt2; i++) {
b *= 7;
b += id[cnt1 + i];
}
if (a < N && b < M) SE.insert(make_pair(a, b));
} while (next_permutation((id).begin(), (id).end()));
cout << int(SE.size()) << endl;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
Nauuo is a girl who loves playing cards.
One day she was playing cards but found that the cards were mixed with some empty ones.
There are n cards numbered from 1 to n, and they were mixed with another n empty cards. She piled up the 2n cards and drew n of them. The n cards in Nauuo's hands are given. The remaining n cards in the pile are also given in the order from top to bottom.
In one operation she can choose a card in her hands and play it — put it at the bottom of the pile, then draw the top card from the pile.
Nauuo wants to make the n numbered cards piled up in increasing order (the i-th card in the pile from top to bottom is the card i) as quickly as possible. Can you tell her the minimum number of operations?
Input
The first line contains a single integer n (1≤ n≤ 2⋅ 10^5) — the number of numbered cards.
The second line contains n integers a_1,a_2,…,a_n (0≤ a_i≤ n) — the initial cards in Nauuo's hands. 0 represents an empty card.
The third line contains n integers b_1,b_2,…,b_n (0≤ b_i≤ n) — the initial cards in the pile, given in order from top to bottom. 0 represents an empty card.
It is guaranteed that each number from 1 to n appears exactly once, either in a_{1..n} or b_{1..n}.
Output
The output contains a single integer — the minimum number of operations to make the n numbered cards piled up in increasing order.
Examples
Input
3
0 2 0
3 0 1
Output
2
Input
3
0 2 0
1 0 3
Output
4
Input
11
0 0 0 5 0 0 0 4 0 0 11
9 2 6 0 8 1 7 0 3 0 10
Output
18
Note
Example 1
We can play the card 2 and draw the card 3 in the first operation. After that, we have [0,3,0] in hands and the cards in the pile are [0,1,2] from top to bottom.
Then, we play the card 3 in the second operation. The cards in the pile are [1,2,3], in which the cards are piled up in increasing order.
Example 2
Play an empty card and draw the card 1, then play 1, 2, 3 in order.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cout.tie(0);
int n;
cin >> n;
vector<bool> in(n + 1);
for (int i = 0; i < n; i++) {
int a;
cin >> a;
in[a] = true;
}
vector<int> b(n);
for (int i = 0; i < n; i++) {
cin >> b[i];
}
int ind = 0;
int next_ = 1;
vector<int> c = b;
for (; next_ <= n; ind++) {
int t = ind - n - 1;
if (t >= 0 && t < n) {
in[b[ind - n - 1]] = true;
}
if (c[ind % n] == next_) {
next_++;
c[ind % n] = -1;
continue;
}
if (c[ind % n] == -1 && in[next_]) {
next_++;
continue;
}
c[ind % n] = -1;
if (ind - next_ + 1 < n) {
next_ = 1;
}
}
cout << ind - n << endl;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
In the spring of 2014, a student successfully passed the university and started living alone. The problem here is what to do with the supper. He decided to plan a supper for the next N days.
He wants to maximize the total happiness he gets in N days. Of course, the more delicious or favorite you eat, the higher your happiness.
His dinner options are two, either head to a nearby dining room or cook for himself.
The happiness you get in the cafeteria depends on the menu of the day. The menu changes daily, but there is only one type every day, and all the menus for N days have already been released. So he knows all the information that if you go to the cafeteria on day i (1 ≤ i ≤ N) you will get the happiness of Ci.
The happiness obtained by self-catering is the self-catering power at the start of self-catering multiplied by a constant P. The initial value of self-catering power is Q, which is -1 if you go to the restaurant every day, +1 if you cook yourself, and fluctuates at the end of the meal of the day.
Find the maximum sum of happiness for him.
Constraints
* 1 ≤ N ≤ 500,000
* 0 ≤ P ≤ 500,000
* | Q | ≤ 500,000
* | Ci | ≤ 500,000
Input
The input is given in the following format as N + 1 line.
N P Q
C1
C2
::
CN
* The first line is given three integers N, P, and Q, which are the number of days, the constant for calculating the happiness of self-catering, and the initial value of self-catering power.
* From the 2nd line to the N + 1st line, one integer is given, and the i + 1st line gives the happiness obtained when going to the cafeteria on the i day.
Output
Output the maximum value of happiness that can be taken in one line.
Examples
Input
1 1 1
2
Output
2
Input
3 2 1
3
3
3
Output
12
Input
3 1 -1
2
-3
2
Output
2
Input
3 1 -10
-10
-10
-10
Output
-27
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main()
{
long long int n, p, q;
cin >> n >> p >> q;
long long int c[n];
long long int d[n];
long long int e[n];
for(long long int i = 0; i < n; i++)
{
cin >> c[i];
d[i] = c[i] + p * i;
}
sort(d, d+n);
for(long long int j = 0; j < n; j++)
{
e[j] = d[j] - p * (q + 2 * j);
}
long long int x = 0;
long long int y = 0;
for(long long int k = 0; k < n; k++)
{
y = y + e[n-1-k];
if(x < y)
{
x = y;
}
}
cout << x + n * p * q + n * (n-1) * p / 2 << endl;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
It has been decided that a programming contest sponsored by company A will be held, so we will post the notice on a bulletin board.
The bulletin board is in the form of a grid with N rows and N columns, and the notice will occupy a rectangular region with H rows and W columns.
How many ways are there to choose where to put the notice so that it completely covers exactly HW squares?
Constraints
* 1 \leq H, W \leq N \leq 100
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
H
W
Output
Print the answer.
Examples
Input
3
2
3
Output
2
Input
100
1
1
Output
10000
Input
5
4
2
Output
8
### Response
```cpp
#include <iostream>
using namespace std;
int main(){
int n,h,w;
cin >> n >> h >> w;
cout << (n-w+1)*(n-h+1) << endl;
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
Recently Polycarp started to develop a text editor that works only with correct bracket sequences (abbreviated as CBS).
Note that a bracket sequence is correct if it is possible to get a correct mathematical expression by adding "+"-s and "1"-s to it. For example, sequences "(())()", "()" and "(()(()))" are correct, while ")(", "(()" and "(()))(" are not. Each bracket in CBS has a pair. For example, in "(()(()))":
* 1st bracket is paired with 8th,
* 2d bracket is paired with 3d,
* 3d bracket is paired with 2d,
* 4th bracket is paired with 7th,
* 5th bracket is paired with 6th,
* 6th bracket is paired with 5th,
* 7th bracket is paired with 4th,
* 8th bracket is paired with 1st.
Polycarp's editor currently supports only three operations during the use of CBS. The cursor in the editor takes the whole position of one of the brackets (not the position between the brackets!). There are three operations being supported:
* «L» — move the cursor one position to the left,
* «R» — move the cursor one position to the right,
* «D» — delete the bracket in which the cursor is located, delete the bracket it's paired to and all brackets between them (that is, delete a substring between the bracket in which the cursor is located and the one it's paired to).
After the operation "D" the cursor moves to the nearest bracket to the right (of course, among the non-deleted). If there is no such bracket (that is, the suffix of the CBS was deleted), then the cursor moves to the nearest bracket to the left (of course, among the non-deleted).
There are pictures illustrated several usages of operation "D" below.
<image>
All incorrect operations (shift cursor over the end of CBS, delete the whole CBS, etc.) are not supported by Polycarp's editor.
Polycarp is very proud of his development, can you implement the functionality of his editor?
Input
The first line contains three positive integers n, m and p (2 ≤ n ≤ 500 000, 1 ≤ m ≤ 500 000, 1 ≤ p ≤ n) — the number of brackets in the correct bracket sequence, the number of operations and the initial position of cursor. Positions in the sequence are numbered from left to right, starting from one. It is guaranteed that n is even.
It is followed by the string of n characters "(" and ")" forming the correct bracket sequence.
Then follow a string of m characters "L", "R" and "D" — a sequence of the operations. Operations are carried out one by one from the first to the last. It is guaranteed that the given operations never move the cursor outside the bracket sequence, as well as the fact that after all operations a bracket sequence will be non-empty.
Output
Print the correct bracket sequence, obtained as a result of applying all operations to the initial sequence.
Examples
Input
8 4 5
(())()()
RDLD
Output
()
Input
12 5 3
((()())(()))
RRDLD
Output
(()(()))
Input
8 8 8
(())()()
LLLLLLDD
Output
()()
Note
In the first sample the cursor is initially at position 5. Consider actions of the editor:
1. command "R" — the cursor moves to the position 6 on the right;
2. command "D" — the deletion of brackets from the position 5 to the position 6. After that CBS takes the form (())(), the cursor is at the position 5;
3. command "L" — the cursor moves to the position 4 on the left;
4. command "D" — the deletion of brackets from the position 1 to the position 4. After that CBS takes the form (), the cursor is at the position 1.
Thus, the answer is equal to ().
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m, p, l, r;
string s, op;
vector<int> der, izq, match;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
while (cin >> n >> m >> p) {
cin >> s;
der = vector<int>(n + 2);
izq = vector<int>(n + 2);
for (int i = 0; i <= n + 1; i++) {
der[i] = i + 1;
izq[i] = i - 1;
}
match = vector<int>(n + 2, -1);
stack<int> st;
for (int i = 0; i < n; i++)
if (s[i] == '(')
st.push(i);
else {
int idx = st.top();
st.pop();
match[idx + 1] = i + 1;
match[i + 1] = idx + 1;
}
cin >> op;
bool empty = false;
for (int i = 0; i < (int)op.size() && !empty; i++)
if (op[i] == 'R') {
if (der[p] >= 1 && der[p] <= n) p = der[p];
} else if (op[i] == 'L') {
if (izq[p] >= 1 && izq[p] <= n) p = izq[p];
} else {
l = match[p];
r = p;
if (l > r) swap(l, r);
izq[der[r]] = izq[l];
der[izq[l]] = der[r];
if (der[izq[l]] >= 1 && der[izq[l]] <= n)
p = der[izq[l]];
else if (izq[der[r]] >= 1 && izq[der[r]] <= n)
p = izq[der[r]];
else
empty = true;
}
if (empty)
cout << '\n';
else {
int pos = 0;
while (pos <= n) {
if (pos != 0) cout << s[pos - 1];
pos = der[pos];
}
cout << '\n';
}
}
return 0;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
You are given a sequence a_1, a_2, …, a_n of non-negative integers.
You need to find the largest number m of triples (i_1, j_1, k_1), (i_2, j_2, k_2), ..., (i_m, j_m, k_m) such that:
* 1 ≤ i_p < j_p < k_p ≤ n for each p in 1, 2, …, m;
* a_{i_p} = a_{k_p} = 0, a_{j_p} ≠ 0;
* all a_{j_1}, a_{j_2}, …, a_{j_m} are different;
* all i_1, j_1, k_1, i_2, j_2, k_2, …, i_m, j_m, k_m are different.
Input
The first line of input contains one integer t (1 ≤ t ≤ 500 000): the number of test cases.
The first line of each test case contains one integer n (1 ≤ n ≤ 500 000).
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ n).
The total sum of n is at most 500 000.
Output
For each test case, print one integer m: the largest number of proper triples that you can find.
Example
Input
8
1
1
2
0 0
3
0 1 0
6
0 0 1 2 0 0
6
0 1 0 0 1 0
6
0 1 3 2 0 0
6
0 0 0 0 5 0
12
0 1 0 2 2 2 0 0 3 3 4 0
Output
0
0
1
2
1
1
1
2
Note
In the first two test cases, there are not enough elements even for a single triple, so the answer is 0.
In the third test case we can select one triple (1, 2, 3).
In the fourth test case we can select two triples (1, 3, 5) and (2, 4, 6).
In the fifth test case we can select one triple (1, 2, 3). We can't select two triples (1, 2, 3) and (4, 5, 6), because a_2 = a_5.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int read() {
int g = 0, f = 1;
char ch = getchar();
while (ch < '0' || '9' < ch) {
if (ch == '-') f = -1;
ch = getchar();
}
while ('0' <= ch && ch <= '9') {
g = g * 10 + ch - '0';
ch = getchar();
}
return g * f;
}
const int N = 5e5 + 5;
int vl[N];
struct Seg {
int mn[N << 2], tag[N << 2];
void up(int v) { mn[v] = min(mn[v << 1], mn[v << 1 | 1]); }
void ud(int v, int w) { tag[v] += w, mn[v] += w; }
void dn(int v) {
if (tag[v]) ud(v << 1, tag[v]), ud(v << 1 | 1, tag[v]), tag[v] = 0;
}
void bu(int v, int l, int r) {
tag[v] = 0;
if (l == r) return mn[v] = vl[l], void();
int mid = l + r >> 1;
bu(v << 1, l, mid), bu(v << 1 | 1, mid + 1, r);
up(v);
}
void ins(int v, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) return ud(v, -1), void();
int mid = l + r >> 1;
dn(v);
if (ql <= mid) ins(v << 1, l, mid, ql, qr);
if (qr > mid) ins(v << 1 | 1, mid + 1, r, ql, qr);
up(v);
}
} seg;
int n, a[N], pre[N], op[N], lmx[N], rmn[N];
void Main() {
int cnt = 0, col = 0, sign = 0;
n = read();
for (int i = (1); i <= (n); i++)
a[i] = read(), cnt += a[i] ? 0 : 1, pre[i] = pre[i - 1] + (a[i] ? 0 : 1);
for (int i = (1); i <= (n); i++) lmx[i] = -1, rmn[i] = -1;
for (int i = (1); i <= (n); i++)
op[i] = (pre[i] - (a[i] ? 0 : 1) >= (cnt >> 1)) ? 2 : 1;
for (int i = (1); i <= (n); i++)
if (a[i] && op[i] == 1) lmx[a[i]] = i;
for (int i = (n); i >= (1); i--)
if (a[i] && op[i] == 2) rmn[a[i]] = i;
for (int i = (1); i <= (n); i++)
if (lmx[i] != -1 || rmn[i] != -1) col++;
for (int i = (1); i <= (n); i++)
if (op[i] == 2 && !a[i]) sign++;
for (int i = (1); i <= (sign + 1); i++) vl[i] = col + sign + 1 - i;
int tot = sign + 1;
seg.bu(1, 1, tot);
for (int i = (1); i <= (n); i++)
if (lmx[i] == -1 && rmn[i] != -1)
seg.ins(1, 1, tot, 1, pre[rmn[i]] + 1 - (cnt >> 1));
int Ans = min(cnt >> 1, seg.mn[1]);
int now = 0;
for (int i = (1); i <= (n); i++)
if (op[i] == 1) {
if (!a[i]) now++;
if (a[i] && i == lmx[a[i]]) {
int x = rmn[a[i]];
if (x != -1)
seg.ins(1, 1, tot, 1, pre[x] + 1 - (cnt >> 1));
else
seg.ins(1, 1, tot, 1, tot);
}
Ans = min(Ans, seg.mn[1] + now);
}
cout << Ans << '\n';
}
signed main() {
for (int T = read(); T--;) Main();
return signed();
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
The tram in Berland goes along a straight line from the point 0 to the point s and back, passing 1 meter per t1 seconds in both directions. It means that the tram is always in the state of uniform rectilinear motion, instantly turning around at points x = 0 and x = s.
Igor is at the point x1. He should reach the point x2. Igor passes 1 meter per t2 seconds.
Your task is to determine the minimum time Igor needs to get from the point x1 to the point x2, if it is known where the tram is and in what direction it goes at the moment Igor comes to the point x1.
Igor can enter the tram unlimited number of times at any moment when his and the tram's positions coincide. It is not obligatory that points in which Igor enter and exit the tram are integers. Assume that any boarding and unboarding happens instantly. Igor can move arbitrary along the line (but not faster than 1 meter per t2 seconds). He can also stand at some point for some time.
Input
The first line contains three integers s, x1 and x2 (2 ≤ s ≤ 1000, 0 ≤ x1, x2 ≤ s, x1 ≠ x2) — the maximum coordinate of the point to which the tram goes, the point Igor is at, and the point he should come to.
The second line contains two integers t1 and t2 (1 ≤ t1, t2 ≤ 1000) — the time in seconds in which the tram passes 1 meter and the time in seconds in which Igor passes 1 meter.
The third line contains two integers p and d (1 ≤ p ≤ s - 1, d is either 1 or <image>) — the position of the tram in the moment Igor came to the point x1 and the direction of the tram at this moment. If <image>, the tram goes in the direction from the point s to the point 0. If d = 1, the tram goes in the direction from the point 0 to the point s.
Output
Print the minimum time in seconds which Igor needs to get from the point x1 to the point x2.
Examples
Input
4 2 4
3 4
1 1
Output
8
Input
5 4 0
1 2
3 1
Output
7
Note
In the first example it is profitable for Igor to go by foot and not to wait the tram. Thus, he has to pass 2 meters and it takes 8 seconds in total, because he passes 1 meter per 4 seconds.
In the second example Igor can, for example, go towards the point x2 and get to the point 1 in 6 seconds (because he has to pass 3 meters, but he passes 1 meters per 2 seconds). At that moment the tram will be at the point 1, so Igor can enter the tram and pass 1 meter in 1 second. Thus, Igor will reach the point x2 in 7 seconds in total.
### Response
```cpp
#include <bits/stdc++.h>
int main() {
int s, x1, x2, t1, t2, p, d;
scanf("%d %d %d", &s, &x1, &x2);
scanf("%d %d", &t1, &t2);
scanf("%d %d", &p, &d);
if (x1 < x2) {
int min1 = (x2 - x1) * t2;
if (t2 <= t1) {
printf("%d\n", min1);
} else {
int min2;
if (d == 1) {
if (p <= x1) {
min2 = (x2 - p) * t1;
} else {
min2 = (2 * s - p + x2) * t1;
}
} else {
min2 = (p + x2) * t1;
}
if (min1 < min2) {
printf("%d\n", min1);
} else {
printf("%d\n", min2);
}
}
} else {
int min1 = (x1 - x2) * t2;
if (t2 <= t1) {
printf("%d\n", min1);
} else {
int min2;
if (d == 1) {
min2 = (s - p + s - x2) * t1;
} else {
if (p >= x1) {
min2 = (p - x2) * t1;
} else {
min2 = (p + 2 * s - x2) * t1;
}
}
if (min1 < min2) {
printf("%d\n", min1);
} else {
printf("%d\n", min2);
}
}
}
return 0;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
n people are standing in a line to play table tennis. At first, the first two players in the line play a game. Then the loser goes to the end of the line, and the winner plays with the next person from the line, and so on. They play until someone wins k games in a row. This player becomes the winner.
For each of the participants, you know the power to play table tennis, and for all players these values are different. In a game the player with greater power always wins. Determine who will be the winner.
Input
The first line contains two integers: n and k (2 ≤ n ≤ 500, 2 ≤ k ≤ 1012) — the number of people and the number of wins.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ n) — powers of the player. It's guaranteed that this line contains a valid permutation, i.e. all ai are distinct.
Output
Output a single integer — power of the winner.
Examples
Input
2 2
1 2
Output
2
Input
4 2
3 1 2 4
Output
3
Input
6 2
6 5 3 1 2 4
Output
6
Input
2 10000000000
2 1
Output
2
Note
Games in the second sample:
3 plays with 1. 3 wins. 1 goes to the end of the line.
3 plays with 2. 3 wins. He wins twice in a row. He becomes the winner.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int n;
long long int k;
cin >> n >> k;
queue<int> q;
int maxx = INT_MIN;
for (int i = 0; i < n; i++) {
int ele;
cin >> ele;
maxx = max(maxx, ele);
q.push(ele);
}
if (k >= n - 1)
cout << maxx;
else {
int wins = 0, winner = q.front();
q.pop();
while (wins < k) {
int p2 = q.front();
q.pop();
if (winner < p2) {
winner = p2;
wins = 1;
q.push(winner);
} else {
wins++;
q.push(p2);
}
}
cout << winner;
}
return 0;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
You are given a connected undirected graph consisting of n vertices and m edges. There are no self-loops or multiple edges in the given graph.
You have to direct its edges in such a way that the obtained directed graph does not contain any paths of length two or greater (where the length of path is denoted as the number of traversed edges).
Input
The first line contains two integer numbers n and m (2 ≤ n ≤ 2 ⋅ 10^5, n - 1 ≤ m ≤ 2 ⋅ 10^5) — the number of vertices and edges, respectively.
The following m lines contain edges: edge i is given as a pair of vertices u_i, v_i (1 ≤ u_i, v_i ≤ n, u_i ≠ v_i). There are no multiple edges in the given graph, i. e. for each pair (u_i, v_i) there are no other pairs (u_i, v_i) and (v_i, u_i) in the list of edges. It is also guaranteed that the given graph is connected (there is a path between any pair of vertex in the given graph).
Output
If it is impossible to direct edges of the given graph in such a way that the obtained directed graph does not contain paths of length at least two, print "NO" in the first line.
Otherwise print "YES" in the first line, and then print any suitable orientation of edges: a binary string (the string consisting only of '0' and '1') of length m. The i-th element of this string should be '0' if the i-th edge of the graph should be directed from u_i to v_i, and '1' otherwise. Edges are numbered in the order they are given in the input.
Example
Input
6 5
1 5
2 1
1 4
3 1
6 1
Output
YES
10100
Note
The picture corresponding to the first example: <image>
And one of possible answers: <image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long N = 200100;
long long visited[N] = {0};
vector<long long> adj[N];
long long color[N] = {0};
void dfs(long long v) {
if (color[v] == 1) {
for (long long x : adj[v]) {
if (color[x] == 0) {
color[x] = 2;
dfs(x);
} else if (color[x] == 1) {
cout << "NO" << '\n';
exit(0);
}
}
} else {
for (long long x : adj[v]) {
if (color[x] == 0) {
color[x] = 1;
dfs(x);
} else if (color[x] == 2) {
cout << "NO" << '\n';
exit(0);
}
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, m, i, j;
cin >> n >> m;
vector<pair<long long, long long> > edge;
for (i = 0; i < m; i++) {
long long a, b;
cin >> a >> b;
edge.push_back({a, b});
adj[a].push_back(b);
adj[b].push_back(a);
}
if (n == 2 && m == 1) {
cout << "YES" << '\n';
cout << 1 << '\n';
return 0;
}
color[1] = 1;
dfs(1);
cout << "YES" << '\n';
for (i = 0; i < m; i++) {
if (color[edge[i].first] == 1) {
cout << 0;
} else {
cout << 1;
}
}
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
While Duff was resting in the beach, she accidentally found a strange array b0, b1, ..., bl - 1 consisting of l positive integers. This array was strange because it was extremely long, but there was another (maybe shorter) array, a0, ..., an - 1 that b can be build from a with formula: bi = ai mod n where a mod b denoted the remainder of dividing a by b.
<image>
Duff is so curious, she wants to know the number of subsequences of b like bi1, bi2, ..., bix (0 ≤ i1 < i2 < ... < ix < l), such that:
* 1 ≤ x ≤ k
* For each 1 ≤ j ≤ x - 1, <image>
* For each 1 ≤ j ≤ x - 1, bij ≤ bij + 1. i.e this subsequence is non-decreasing.
Since this number can be very large, she want to know it modulo 109 + 7.
Duff is not a programmer, and Malek is unavailable at the moment. So she asked for your help. Please tell her this number.
Input
The first line of input contains three integers, n, l and k (1 ≤ n, k, n × k ≤ 106 and 1 ≤ l ≤ 1018).
The second line contains n space separated integers, a0, a1, ..., an - 1 (1 ≤ ai ≤ 109 for each 0 ≤ i ≤ n - 1).
Output
Print the answer modulo 1 000 000 007 in one line.
Examples
Input
3 5 3
5 9 1
Output
10
Input
5 10 3
1 2 3 4 5
Output
25
Note
In the first sample case, <image>. So all such sequences are: <image>, <image>, <image>, <image>, <image>, <image>, <image>, <image>, <image> and <image>.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int base = (int)1e9 + 7;
int n, k;
long long l;
int a[1000005];
int gt[1000005];
long long res = 0;
long long mul(long long a, int b) {
long long re = 0;
long long c = a;
while (b) {
if (b & 1) re = (re + c) % base;
c = (c + c) % base;
b /= 2;
}
return re;
}
int main() {
cin >> n >> l >> k;
vector<vector<int> > f(k + 5, vector<int>(n + 5));
vector<vector<int> > sum(k + 5, vector<int>(n + 5));
vector<int> g(n + 5);
vector<int> b(n + 5);
map<int, int> Map;
Map.clear();
for (int i = 1; i <= n; ++i) {
scanf("%d", a + i);
b[i] = a[i];
}
sort(a + 1, a + 1 + n);
for (int i = n; i >= 1; --i) {
if (a[i] == a[i + 1])
g[i] = g[i + 1];
else
g[i] = i;
Map[a[i]] = g[i];
sum[0][i] = 1;
}
for (int i = 1; i <= k; ++i) {
for (int j = 1; j <= n; ++j) {
f[i][j] = sum[i - 1][g[j]];
sum[i][j] = (sum[i][j - 1] + f[i][j]) % base;
}
long long tmp1 = 0;
for (int j = 1; j <= l % n; ++j)
tmp1 = (tmp1 + sum[i - 1][Map[b[j]]]) % base;
long long t1 = l / n + (l % n != 0);
long long tmp = 0;
if (t1 >= i) {
if (l % n == 0)
tmp = mul(t1 - i + 1, sum[i][n]);
else
tmp = (mul(t1 - i, sum[i][n]) + tmp1) % base;
}
res = (res + tmp) % base;
}
cout << res << endl;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
Given an array a of length n, tell us whether it has a non-empty subsequence such that the product of its elements is not a perfect square.
A sequence b is a subsequence of an array a if b can be obtained from a by deleting some (possibly zero) elements.
Input
The first line contains an integer t (1 ≤ t ≤ 100) — the number of test cases. The description of the test cases follows.
The first line of each test case contains an integer n (1 ≤ n ≤ 100) — the length of the array a.
The second line of each test case contains n integers a_1, a_2, …, a_{n} (1 ≤ a_i ≤ 10^4) — the elements of the array a.
Output
If there's a subsequence of a whose product isn't a perfect square, print "YES". Otherwise, print "NO".
Example
Input
2
3
1 5 4
2
100 10000
Output
YES
NO
Note
In the first example, the product of the whole array (20) isn't a perfect square.
In the second example, all subsequences have a perfect square product.
### Response
```cpp
#include <bits/stdc++.h>
#include <list>
#include <stack>
using namespace std;
#define ll long long
#define fo(i,n) for(int i=0;i<n;i++)
#define rep(i,k,n) for(int i=k;k<n?i<n:i>n;k<n?i+=1:i-=1)
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define all(x) x.begin(), x.end()
#define clr(x) memset(x, 0, sizeof(x))
#define ini(a, i) memset(a, i, sizeof(a))
#define sortall(x) sort(all(x))
#define rev(x) reverse(all(x))
#define PI 3.1415926535897932384626
typedef pair<ll, ll> pii;
typedef pair<ll, ll> pl;
typedef vector<ll> vi;
typedef vector<ll> vl;
typedef vector<pii> vpii;
typedef vector<pl> vpl;
typedef vector<vi> vvi;
typedef vector<vl> vvl;
const int INF = 1000000007;
const long long INFLL = (ll)INF * (ll)INF;
#define ld long double
const ld EPS = 10e-9;
const unsigned int M = 1000000007;
#define int long long
long double pi = 2*acos(0.0);
// cout << fixed << setprecision(0) << pi <<" "<<npi<<endl;
//s.substr(start index,length)
//lower_bound
//upper_bound
//*max_element
//*min_element
//continue
// vector<vector<int>> vec( n , vector<int> (m, 0));
// in a matrix if i select cell a(i,j) then the parity of (i+j) all the adjacent cells is opposite
//check cube root
// double b=cbrt(x-a*a*a);
// if(floor(b)==b)
// {
// yes;return;
// }
//const bool is_in = container.find(element) != container.end();
//int chalao=1000000000000;
// x has cbrt(x) divisors
// pass string by reference
// PREFER DP[MIN_SIZE][MAX_SIZE] OVER DP[MAX_SIZE][MIN_SIZE]
int mod=1000000007;
// int dp[1003][1003];
// memset(dp,-1,sizeof(dp));
void solve()
{
int n;
cin>>n;
int a[n];
int flag=0;
for (int i = 0; i < n; ++i)
{
cin>>a[i];
double ash=sqrt((double)a[i]);
if(floor(ash)!=ceil(ash))
flag=1;
}
if(flag==1)
{
cout<<"YES"<<endl;
}
else
cout<<"NO"<<endl;
}
int32_t main()
{
clock_t start, end;
start = clock();
// ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif // ONLINE_JUDGE
// sieve();
// initalize();
int t=1;
cin>>t;
while(t--)
solve();
// cout<<primes.size();
//cout<<t1;
end = clock();
// // Calculating total time taken by the program.
// double time_taken = double(end - start) / double(CLOCKS_PER_SEC);
// cout << "\nTime taken by program is : " << fixed << time_taken << setprecision(5);
// cout << " sec " << endl;
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
Lunar New Year is approaching, and Bob is struggling with his homework – a number division problem.
There are n positive integers a_1, a_2, …, a_n on Bob's homework paper, where n is always an even number. Bob is asked to divide those numbers into groups, where each group must contain at least 2 numbers. Suppose the numbers are divided into m groups, and the sum of the numbers in the j-th group is s_j. Bob's aim is to minimize the sum of the square of s_j, that is $$$∑_{j = 1}^{m} s_j^2.$$$
Bob is puzzled by this hard problem. Could you please help him solve it?
Input
The first line contains an even integer n (2 ≤ n ≤ 3 ⋅ 10^5), denoting that there are n integers on Bob's homework paper.
The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^4), describing the numbers you need to deal with.
Output
A single line containing one integer, denoting the minimum of the sum of the square of s_j, which is $$$∑_{i = j}^{m} s_j^2, where m$$$ is the number of groups.
Examples
Input
4
8 5 2 3
Output
164
Input
6
1 1 1 2 2 2
Output
27
Note
In the first sample, one of the optimal solutions is to divide those 4 numbers into 2 groups \{2, 8\}, \{5, 3\}. Thus the answer is (2 + 8)^2 + (5 + 3)^2 = 164.
In the second sample, one of the optimal solutions is to divide those 6 numbers into 3 groups \{1, 2\}, \{1, 2\}, \{1, 2\}. Thus the answer is (1 + 2)^2 + (1 + 2)^2 + (1 + 2)^2 = 27.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int n;
cin >> n;
long long int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
long long int ans = 0;
for (int i = 0; i < n / 2; i++) {
long long int numone = a[i];
long long int numtwo = a[n - i - 1];
long long int sum = numtwo + numone;
ans += (sum * sum);
}
cout << ans << endl;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
User ainta has a stack of n red and blue balls. He can apply a certain operation which changes the colors of the balls inside the stack.
* While the top ball inside the stack is red, pop the ball from the top of the stack.
* Then replace the blue ball on the top with a red ball.
* And finally push some blue balls to the stack until the stack has total of n balls inside.
If there are no blue balls inside the stack, ainta can't apply this operation. Given the initial state of the stack, ainta wants to know the maximum number of operations he can repeatedly apply.
Input
The first line contains an integer n (1 ≤ n ≤ 50) — the number of balls inside the stack.
The second line contains a string s (|s| = n) describing the initial state of the stack. The i-th character of the string s denotes the color of the i-th ball (we'll number the balls from top to bottom of the stack). If the character is "R", the color is red. If the character is "B", the color is blue.
Output
Print the maximum number of operations ainta can repeatedly apply.
Please, do not write the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
3
RBR
Output
2
Input
4
RBBR
Output
6
Input
5
RBBRR
Output
6
Note
The first example is depicted below.
The explanation how user ainta applies the first operation. He pops out one red ball, changes the color of the ball in the middle from blue to red, and pushes one blue ball.
<image>
The explanation how user ainta applies the second operation. He will not pop out red balls, he simply changes the color of the ball on the top from blue to red.
<image>
From now on, ainta can't apply any operation because there are no blue balls inside the stack. ainta applied two operations, so the answer is 2.
The second example is depicted below. The blue arrow denotes a single operation.
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s;
cin >> s;
long long count = 0;
for (int i = 0; i < n; i++) {
if (s[i] == 'B') count += pow(2, i);
}
cout << count << endl;
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Snuke lives in another world, where slimes are real creatures and kept by some people. Slimes come in N colors. Those colors are conveniently numbered 1 through N. Snuke currently has no slime. His objective is to have slimes of all the colors together.
Snuke can perform the following two actions:
* Select a color i (1≤i≤N), such that he does not currently have a slime in color i, and catch a slime in color i. This action takes him a_i seconds.
* Cast a spell, which changes the color of all the slimes that he currently has. The color of a slime in color i (1≤i≤N-1) will become color i+1, and the color of a slime in color N will become color 1. This action takes him x seconds.
Find the minimum time that Snuke needs to have slimes in all N colors.
Constraints
* 2≤N≤2,000
* a_i are integers.
* 1≤a_i≤10^9
* x is an integer.
* 1≤x≤10^9
Input
The input is given from Standard Input in the following format:
N x
a_1 a_2 ... a_N
Output
Find the minimum time that Snuke needs to have slimes in all N colors.
Examples
Input
2 10
1 100
Output
12
Input
3 10
100 1 100
Output
23
Input
4 10
1 2 3 4
Output
10
### Response
```cpp
#include <iostream>
using namespace std;
long long a[3000],b[3000];
int main(){
long long ans=1234123412341234,x,ans0=0;int n;
cin>>n>>x;
for(int i=0;i<n;i++){
cin>>a[i];b[i]=a[i];ans0+=a[i];
}
for(int i=1;i<=n;i++){
if(ans>ans0)ans=ans0;
ans0+=x;
for(int j=0;j<n;j++){
int k=j-i;
while(k<0)k+=n;
if(b[j]>a[k]){
ans0-=(b[j]-a[k]);
b[j]=a[k];
}
}
}
cout<<ans<<endl;
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
N friends of Takahashi has come to a theme park.
To ride the most popular roller coaster in the park, you must be at least K centimeters tall.
The i-th friend is h_i centimeters tall.
How many of the Takahashi's friends can ride the roller coaster?
Constraints
* 1 \le N \le 10^5
* 1 \le K \le 500
* 1 \le h_i \le 500
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N K
h_1 h_2 \ldots h_N
Output
Print the number of people among the Takahashi's friends who can ride the roller coaster.
Examples
Input
4 150
150 140 100 200
Output
2
Input
1 500
499
Output
0
Input
5 1
100 200 300 400 500
Output
5
### Response
```cpp
#include <iostream>
using namespace std;
int main(){
int A,B,C=0;
cin>>A>>B;
int D[A];
for(int i=0;i<A;i++){
cin>>D[i];
if(D[i]>=B) C++;
}
cout<<C;
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
Among other things, Bob is keen on photography. Especially he likes to take pictures of sportsmen. That was the reason why he placed himself in position x0 of a long straight racetrack and got ready to take pictures. But the problem was that not all the runners passed him. The total amount of sportsmen, training at that racetrack, equals n. And each of them regularly runs distances within a particular segment of the racetrack, which is the same for each sportsman. For example, the first sportsman runs from position a1 to position b1, the second — from a2 to b2
What is the minimum distance that Bob should move to have a chance to take pictures of each sportsman? Bob can take a picture of a sportsman, if he stands within the segment that this sportsman covers on the racetrack.
Input
The first line of the input file contains integers n and x0 (1 ≤ n ≤ 100; 0 ≤ x0 ≤ 1000). The following n lines contain pairs of integers ai, bi (0 ≤ ai, bi ≤ 1000; ai ≠ bi).
Output
Output the required minimum distance in the same units as the positions on the racetrack. If there is no such a position, output -1.
Examples
Input
3 3
0 7
14 2
4 6
Output
1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int const N = 1234;
int a[N], n, m, ans = 10 * N;
int main() {
scanf("%d%d", &n, &m);
for (register int i = 1; i <= n; i++) {
int x, y;
scanf("%d%d", &x, &y);
if (x > y) swap(x, y);
for (register int j = x; j <= y; j++) {
a[j]++;
if (a[j] == n) {
if (abs(j - m) < ans) ans = abs(j - m);
}
}
}
if (ans == 10 * N)
puts("-1");
else
printf("%d", ans);
return 0;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
Write a program which reads a sequence of integers $A = \\{a_0, a_1, ..., a_{n-1}\\}$ and rotate specified elements by a list of the following operation:
* rotate($b, m, e$): For each integer $k$ ($0 \leq k < (e - b)$), move element $b + k$ to the place of element $b + ((k + (e - m)) \mod (e - b))$.
Constraints
* $1 \leq n \leq 1,000$
* $-1,000,000,000 \leq a_i \leq 1,000,000,000$
* $1 \leq q \leq 1,000$
* $0 \leq b_i \leq m_i < e_i \leq n$
Input
The input is given in the following format.
$n$
$a_0 \; a_1 \; ...,\; a_{n-1}$
$q$
$b_1 \; m_1 \; e_1$
$b_2 \; m_2 \; e_2$
:
$b_{q} \; m_{q} \; e_{q}$
In the first line, $n$ (the number of elements in $A$) is given. In the second line, $a_i$ (each element in $A$) are given. In the third line, the number of queries $q$ is given and each query is given by three integers $b_i \; m_i \; e_i$ in the following $q$ lines.
Output
Print all elements of $A$ in a line after performing the given operations. Put a single space character between adjacency elements and a newline at the end of the last element.
Example
Input
11
1 2 3 4 5 6 7 8 9 10 11
1
2 6 9
Output
1 2 7 8 9 3 4 5 6 10 11
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for (int i = 0; i < (n); i++)
#define repd(i,a,b) for (int i = (a); i < (b); i++)
typedef long long ll;
int main(void)
{
int n, a, q, b, m, e;
vector<int> A;
cin >> n;
rep(i, n)
{
cin >> a;
A.push_back(a);
}
cin >> q;
rep(i, q)
{
cin >> b >> m >> e;
rotate(A.begin() + b, A.begin() + m, A.begin() + e);
}
rep(i, n)
{
if (i)
{
cout << " ";
}
cout << A[i];
}
cout << endl;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
Berland scientists face a very important task - given the parts of short DNA fragments, restore the dinosaur DNA! The genome of a berland dinosaur has noting in common with the genome that we've used to: it can have 26 distinct nucleotide types, a nucleotide of each type can occur at most once. If we assign distinct English letters to all nucleotides, then the genome of a Berland dinosaur will represent a non-empty string consisting of small English letters, such that each letter occurs in it at most once.
Scientists have n genome fragments that are represented as substrings (non-empty sequences of consecutive nucleotides) of the sought genome.
You face the following problem: help scientists restore the dinosaur genome. It is guaranteed that the input is not contradictory and at least one suitable line always exists. When the scientists found out that you are a strong programmer, they asked you in addition to choose the one with the minimum length. If there are multiple such strings, choose any string.
Input
The first line of the input contains a positive integer n (1 ≤ n ≤ 100) — the number of genome fragments.
Each of the next lines contains one descriptions of a fragment. Each fragment is a non-empty string consisting of distinct small letters of the English alphabet. It is not guaranteed that the given fragments are distinct. Fragments could arbitrarily overlap and one fragment could be a substring of another one.
It is guaranteed that there is such string of distinct letters that contains all the given fragments as substrings.
Output
In the single line of the output print the genome of the minimum length that contains all the given parts. All the nucleotides in the genome must be distinct. If there are multiple suitable strings, print the string of the minimum length. If there also are multiple suitable strings, you can print any of them.
Examples
Input
3
bcd
ab
cdef
Output
abcdef
Input
4
x
y
z
w
Output
xyzw
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
char s[30];
bool used[30] = {};
int nx[30] = {};
int indeg[30] = {};
cin >> n;
memset(nx, -1, sizeof nx);
for (int i = 0; i < n; i++) {
cin >> s;
int len = strlen(s);
for (int j = 0; j < len; j++) used[s[j] - 'a'] = true;
for (int j = 0; j < len - 1; j++) {
nx[s[j] - 'a'] = s[j + 1] - 'a';
++indeg[s[j + 1] - 'a'];
}
}
string ans = "";
for (int i = 0; i < 26; i++) {
if (used[i] && !indeg[i]) {
for (int c = i; c != -1; c = nx[c]) {
ans += char(c + 'a');
}
}
}
cout << ans << endl;
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
The administration of the Tomsk Region firmly believes that it's time to become a megacity (that is, get population of one million). Instead of improving the demographic situation, they decided to achieve its goal by expanding the boundaries of the city.
The city of Tomsk can be represented as point on the plane with coordinates (0; 0). The city is surrounded with n other locations, the i-th one has coordinates (xi, yi) with the population of ki people. You can widen the city boundaries to a circle of radius r. In such case all locations inside the circle and on its border are included into the city.
Your goal is to write a program that will determine the minimum radius r, to which is necessary to expand the boundaries of Tomsk, so that it becomes a megacity.
Input
The first line of the input contains two integers n and s (1 ≤ n ≤ 103; 1 ≤ s < 106) — the number of locatons around Tomsk city and the population of the city. Then n lines follow. The i-th line contains three integers — the xi and yi coordinate values of the i-th location and the number ki of people in it (1 ≤ ki < 106). Each coordinate is an integer and doesn't exceed 104 in its absolute value.
It is guaranteed that no two locations are at the same point and no location is at point (0; 0).
Output
In the output, print "-1" (without the quotes), if Tomsk won't be able to become a megacity. Otherwise, in the first line print a single real number — the minimum radius of the circle that the city needs to expand to in order to become a megacity.
The answer is considered correct if the absolute or relative error don't exceed 10 - 6.
Examples
Input
4 999998
1 1 1
2 2 1
3 3 1
2 -2 1
Output
2.8284271
Input
4 999998
1 1 2
2 2 1
3 3 1
2 -2 1
Output
1.4142136
Input
2 1
1 1 999997
2 2 1
Output
-1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > v;
int main() {
int n, p, a = 0, x, y, z;
cin >> n >> p;
for (int i = 0; i < n; i++) {
cin >> x >> y >> z;
v.push_back(make_pair(x * x + y * y, z));
a += z;
}
if ((p + a) < 1000000) {
cout << -1;
return 0;
}
sort(v.begin(), v.end());
int r = 0, c = 0;
for (int i = 0; i < n; i++) {
c += v[i].second;
if ((c + p) >= 1000000) {
r = v[i].first;
break;
}
}
double ans = sqrt(1.0 * r);
printf("%.6f", ans);
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
You work in a big office. It is a 9 floor building with an elevator that can accommodate up to 4 people. It is your responsibility to manage this elevator.
Today you are late, so there are queues on some floors already. For each person you know the floor where he currently is and the floor he wants to reach. Also, you know the order in which people came to the elevator.
According to the company's rules, if an employee comes to the elevator earlier than another one, he has to enter the elevator earlier too (even if these employees stay on different floors). Note that the employees are allowed to leave the elevator in arbitrary order.
The elevator has two commands:
* Go up or down one floor. The movement takes 1 second.
* Open the doors on the current floor. During this operation all the employees who have reached their destination get out of the elevator. Then all the employees on the floor get in the elevator in the order they are queued up while it doesn't contradict the company's rules and there is enough space in the elevator. Each employee spends 1 second to get inside and outside the elevator.
Initially the elevator is empty and is located on the floor 1.
You are interested what is the minimum possible time you need to spend to deliver all the employees to their destination. It is not necessary to return the elevator to the floor 1.
Input
The first line contains an integer n (1 ≤ n ≤ 2000) — the number of employees.
The i-th of the next n lines contains two integers ai and bi (1 ≤ ai, bi ≤ 9, ai ≠ bi) — the floor on which an employee initially is, and the floor he wants to reach.
The employees are given in the order they came to the elevator.
Output
Print a single integer — the minimal possible time in seconds.
Examples
Input
2
3 5
5 3
Output
10
Input
2
5 3
3 5
Output
12
Note
Explaination for the first sample <image> t = 0
<image> t = 2
<image> t = 3
<image> t = 5
<image> t = 6
<image> t = 7
<image> t = 9
<image> t = 10
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
multiset<int> s;
map<multiset<int>, int> mmp;
multiset<int> ssr[720];
void dfs(int stp) {
if (stp == 5) {
mmp[s] = 0;
return;
}
for (int i = 1; i <= 9; i++) {
dfs(stp + 1);
s.insert(i);
dfs(stp + 1);
s.erase(s.find(i));
}
}
int dp[2005][10][720];
int up[720][10];
pair<int, int> down[720][5];
struct node {
int i, j, k;
int val;
bool operator<(const node &t) const { return val > t.val; }
};
void show(int x) {
for (auto it = ssr[x].begin(); it != ssr[x].end(); it++) cout << *it << " ";
cout << endl;
}
int n;
int a[2005], b[2005];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
dfs(1);
int L = 0;
for (auto it = mmp.begin(); it != mmp.end(); it++) {
it->second = ++L;
ssr[L] = it->first;
}
for (int state = 1; state <= 715; state++) {
multiset<int> s = ssr[state];
if (ssr[state].size() < 4) {
for (int i = 1; i <= 9; i++) {
s.insert(i);
up[state][i] = mmp[s];
s.erase(s.find(i));
}
}
if (ssr[state].size()) {
int i = 0;
for (auto it = ssr[state].begin(); it != ssr[state].end(); it++) {
s.erase(s.find(*it));
down[state][++i] = {mmp[s], *it};
s.insert(*it);
}
}
}
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i] >> b[i];
memset(dp, 0x3f, sizeof dp);
dp[0][1][1] = 0;
priority_queue<node> q;
q.push({0, 1, 1, 0});
while (!q.empty()) {
int ui = q.top().i, uj = q.top().j, uk = q.top().k, val = q.top().val;
q.pop();
if (ui == n && uk == 1) break;
for (int i = 1; i <= 4; i++) {
if (!down[uk][i].first) break;
int nk = down[uk][i].first, nj = down[uk][i].second;
if (dp[ui][nj][nk] > dp[ui][uj][uk] + abs(nj - uj)) {
dp[ui][nj][nk] = dp[ui][uj][uk] + abs(nj - uj);
q.push({ui, nj, nk, dp[ui][nj][nk]});
}
}
int nk = up[uk][b[ui + 1]];
if (nk) {
int nj = a[ui + 1];
if (dp[ui + 1][nj][nk] > dp[ui][uj][uk] + abs(nj - uj)) {
dp[ui + 1][nj][nk] = dp[ui][uj][uk] + abs(nj - uj);
q.push({ui + 1, nj, nk, dp[ui + 1][nj][nk]});
}
}
}
int ans = 0x3f3f3f3f;
for (int i = 1; i <= 9; i++) ans = min(ans, dp[n][i][1]);
cout << ans + 2 * n << endl;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
As we all know, Max is the best video game player among her friends. Her friends were so jealous of hers, that they created an actual game just to prove that she's not the best at games. The game is played on a directed acyclic graph (a DAG) with n vertices and m edges. There's a character written on each edge, a lowercase English letter.
<image>
Max and Lucas are playing the game. Max goes first, then Lucas, then Max again and so on. Each player has a marble, initially located at some vertex. Each player in his/her turn should move his/her marble along some edge (a player can move the marble from vertex v to vertex u if there's an outgoing edge from v to u). If the player moves his/her marble from vertex v to vertex u, the "character" of that round is the character written on the edge from v to u. There's one additional rule; the ASCII code of character of round i should be greater than or equal to the ASCII code of character of round i - 1 (for i > 1). The rounds are numbered for both players together, i. e. Max goes in odd numbers, Lucas goes in even numbers. The player that can't make a move loses the game. The marbles may be at the same vertex at the same time.
Since the game could take a while and Lucas and Max have to focus on finding Dart, they don't have time to play. So they asked you, if they both play optimally, who wins the game?
You have to determine the winner of the game for all initial positions of the marbles.
Input
The first line of input contains two integers n and m (2 ≤ n ≤ 100, <image>).
The next m lines contain the edges. Each line contains two integers v, u and a lowercase English letter c, meaning there's an edge from v to u written c on it (1 ≤ v, u ≤ n, v ≠ u). There's at most one edge between any pair of vertices. It is guaranteed that the graph is acyclic.
Output
Print n lines, a string of length n in each one. The j-th character in i-th line should be 'A' if Max will win the game in case her marble is initially at vertex i and Lucas's marble is initially at vertex j, and 'B' otherwise.
Examples
Input
4 4
1 2 b
1 3 a
2 4 c
3 4 b
Output
BAAA
ABAA
BBBA
BBBB
Input
5 8
5 3 h
1 2 c
3 1 c
3 2 r
5 1 r
4 3 z
5 4 r
5 2 h
Output
BABBB
BBBBB
AABBB
AAABA
AAAAB
Note
Here's the graph in the first sample test case:
<image>
Here's the graph in the second sample test case:
<image>
### Response
```cpp
#include <bits/stdc++.h>
inline int two(int n) { return 1 << n; }
inline int test(int n, int b) { return (n >> b) & 1; }
inline void set_bit(int& n, int b) { n |= two(b); }
inline void unset_bit(int& n, int b) { n &= ~two(b); }
inline int last_bit(int n) { return n & (-n); }
inline int ones(int n) {
int res = 0;
while (n && ++res) n -= n & (-n);
return res;
}
long long int gcd(long long int a, long long int b) {
return (a ? gcd(b % a, a) : b);
}
long long int modPow(long long int a, long long int b, long long int MOD) {
long long int x = 1, y = a;
while (b > 0) {
if (b % 2 == 1) {
x = (x * y) % MOD;
}
b /= 2;
y = (y * y) % MOD;
}
return x;
}
long long int modInverse(long long int a, long long int p) {
return modPow(a, p - 2, p);
}
using namespace std;
int dp[101][101][101];
vector<pair<int, int> > adj[101];
int solve(int v, int u, int ch) {
if (dp[v][u][ch] != -1) return dp[v][u][ch];
int ans = 0;
for (auto x : adj[v]) {
if (x.second >= ch) ans |= !solve(u, x.first, x.second);
}
return (dp[v][u][ch] = ans);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
memset(dp, -1, sizeof(dp));
int n, m, u, v;
char ch;
cin >> n >> m;
for (auto i = (1); i <= (m); i++) {
cin >> u >> v >> ch;
adj[u].push_back({v, ch - 'a'});
}
for (auto i = (1); i <= (n); i++) {
for (auto j = (1); j <= (n); j++) {
if (solve(i, j, 0))
cout << "A";
else
cout << "B";
}
cout << endl;
}
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
While discussing a proper problem A for a Codeforces Round, Kostya created a cyclic array of positive integers a_1, a_2, …, a_n. Since the talk was long and not promising, Kostya created a new cyclic array b_1, b_2, …, b_{n} so that b_i = (a_i mod a_{i + 1}), where we take a_{n+1} = a_1. Here mod is the [modulo operation](https://en.wikipedia.org/wiki/Modulo_operation). When the talk became interesting, Kostya completely forgot how array a had looked like. Suddenly, he thought that restoring array a from array b would be an interesting problem (unfortunately, not A).
Input
The first line contains a single integer n (2 ≤ n ≤ 140582) — the length of the array a.
The second line contains n integers b_1, b_2, …, b_{n} (0 ≤ b_i ≤ 187126).
Output
If it is possible to restore some array a of length n so that b_i = a_i mod a_{(i mod n) + 1} holds for all i = 1, 2, …, n, print «YES» in the first line and the integers a_1, a_2, …, a_n in the second line. All a_i should satisfy 1 ≤ a_i ≤ 10^{18}. We can show that if an answer exists, then an answer with such constraint exists as well.
It it impossible to restore any valid a, print «NO» in one line.
You can print each letter in any case (upper or lower).
Examples
Input
4
1 3 1 0
Output
YES
1 3 5 2
Input
2
4 4
Output
NO
Note
In the first example:
* 1 mod 3 = 1
* 3 mod 5 = 3
* 5 mod 2 = 1
* 2 mod 1 = 0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 140582 + 5;
int n, a[MAXN], mx = 0, v = 0;
long long b[MAXN];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
bool flg = 1;
for (int i = 2; i <= n; i++) flg &= (a[i] == a[1]);
if (flg && a[1] == 0) {
puts("YES");
for (int i = 1; i <= n; i++) printf("1 ");
printf("\n");
return 0;
}
if (flg) return puts("NO"), 0;
for (int i = 1; i <= n; i++) (a[i] > mx) ? (mx = a[i], v = i) : 0;
while (a[v] == mx) {
v--;
if (!v) v = n;
}
v++;
if (v == n + 1) v = 1;
long long x = 0;
for (int i = 1; i <= n; i++) {
if (i == 2) x += mx;
x += a[v];
b[v] = x;
v--;
if (!v) v = n;
}
puts("YES");
for (int i = 1; i <= n; i++) printf("%lld ", b[i]);
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
Polycarpus works as a programmer in a start-up social network. His boss gave his a task to develop a mechanism for determining suggested friends. Polycarpus thought much about the task and came to the folowing conclusion.
Let's say that all friendship relationships in a social network are given as m username pairs ai, bi (ai ≠ bi). Each pair ai, bi means that users ai and bi are friends. Friendship is symmetric, that is, if ai is friends with bi, then bi is also friends with ai. User y is a suggested friend for user x, if the following conditions are met:
1. x ≠ y;
2. x and y aren't friends;
3. among all network users who meet the first two conditions, user y has most of all common friends with user x. User z is a common friend of user x and user y (z ≠ x, z ≠ y), if x and z are friends, and y and z are also friends.
Your task is to help Polycarpus to implement a mechanism for determining suggested friends.
Input
The first line contains a single integer m (1 ≤ m ≤ 5000) — the number of pairs of friends in the social network. Next m lines contain pairs of names of the users who are friends with each other. The i-th line contains two space-separated names ai and bi (ai ≠ bi). The users' names are non-empty and consist of at most 20 uppercase and lowercase English letters.
It is guaranteed that each pair of friends occurs only once in the input. For example, the input can't contain x, y and y, x at the same time. It is guaranteed that distinct users have distinct names. It is guaranteed that each social network user has at least one friend. The last thing guarantees that each username occurs at least once in the input.
Output
In the first line print a single integer n — the number of network users. In next n lines print the number of suggested friends for each user. In the i-th line print the name of the user ci and the number of his suggested friends di after a space.
You can print information about the users in any order.
Examples
Input
5
Mike Gerald
Kate Mike
Kate Tank
Gerald Tank
Gerald David
Output
5
Mike 1
Gerald 1
Kate 1
Tank 1
David 2
Input
4
valera vanya
valera edik
pasha valera
igor valera
Output
5
valera 0
vanya 3
edik 3
pasha 3
igor 3
Note
In the first test case consider user David. Users Mike and Tank have one common friend (Gerald) with David. User Kate has no common friends with David. That's why David's suggested friends are users Mike and Tank.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e4 + 10;
map<string, int> m;
map<int, string> m2;
int s[MAXN];
vector<pair<int, int> > v;
bitset<10010> g;
int main() {
ios::sync_with_stdio(false);
int n, cnt = 1;
cin >> n;
for (int i = 0; i < n; i++) {
string a, b;
cin >> a >> b;
if (m[a] == 0) m[a] = cnt++, m2[cnt - 1] = a;
if (m[b] == 0) m[b] = cnt++, m2[cnt - 1] = b;
int x = m[a], y = m[b];
v.push_back({m[a], m[b]});
}
cnt--;
cout << cnt << endl;
for (int i = 1; i <= cnt; i++) {
g = 0;
for (pair<int, int> p : v)
if (p.first == i)
g[p.second] = 1;
else if (p.second == i)
g[p.first] = 1;
memset(s, 0, sizeof s);
for (pair<int, int> p : v) {
if (g[p.first]) s[p.second]++;
if (g[p.second]) s[p.first]++;
}
int ind = 0, ans = 0;
for (int j = 1; j <= cnt; j++)
if (g[j] == 0 and j != i and s[j] > s[ind]) ind = j;
for (int j = 1; j <= cnt; j++)
if (g[j] == 0 and j != i and s[j] == s[ind]) ans++;
cout << m2[i] << " " << ans << "\n";
}
return 0;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
The ship crashed into a reef and is sinking. Now the entire crew must be evacuated. All n crew members have already lined up in a row (for convenience let's label them all from left to right with positive integers from 1 to n) and await further instructions. However, one should evacuate the crew properly, in a strict order. Specifically:
The first crew members to leave the ship are rats. Then women and children (both groups have the same priority) leave the ship. After that all men are evacuated from the ship. The captain leaves the sinking ship last.
If we cannot determine exactly who should leave the ship first for any two members of the crew by the rules from the previous paragraph, then the one who stands to the left in the line leaves the ship first (or in other words, the one whose number in the line is less).
For each crew member we know his status as a crew member, and also his name. All crew members have different names. Determine the order in which to evacuate the crew.
Input
The first line contains an integer n, which is the number of people in the crew (1 ≤ n ≤ 100). Then follow n lines. The i-th of those lines contains two words — the name of the crew member who is i-th in line, and his status on the ship. The words are separated by exactly one space. There are no other spaces in the line. The names consist of Latin letters, the first letter is uppercase, the rest are lowercase. The length of any name is from 1 to 10 characters. The status can have the following values: rat for a rat, woman for a woman, child for a child, man for a man, captain for the captain. The crew contains exactly one captain.
Output
Print n lines. The i-th of them should contain the name of the crew member who must be the i-th one to leave the ship.
Examples
Input
6
Jack captain
Alice woman
Charlie man
Teddy rat
Bob child
Julia woman
Output
Teddy
Alice
Bob
Julia
Charlie
Jack
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s, h;
vector<pair<string, string> > t1, t2, t3, t4;
for (int i = 0; i < n; i++) {
cin >> s >> h;
if (h == "rat")
t1.push_back({s, h});
else if (h == "woman" || h == "child")
t2.push_back({s, h});
else if (h == "man")
t3.push_back({s, h});
else
t4.push_back({s, h});
}
for (int i = 0; i < t1.size(); i++) cout << t1[i].first << endl;
for (int i = 0; i < t2.size(); i++) cout << t2[i].first << endl;
for (int i = 0; i < t3.size(); i++) cout << t3[i].first << endl;
for (int i = 0; i < t4.size(); i++) cout << t4[i].first << endl;
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Amr has got a large array of size n. Amr doesn't like large arrays so he intends to make it smaller.
Amr doesn't care about anything in the array except the beauty of it. The beauty of the array is defined to be the maximum number of times that some number occurs in this array. He wants to choose the smallest subsegment of this array such that the beauty of it will be the same as the original array.
Help Amr by choosing the smallest subsegment possible.
Input
The first line contains one number n (1 ≤ n ≤ 105), the size of the array.
The second line contains n integers ai (1 ≤ ai ≤ 106), representing elements of the array.
Output
Output two integers l, r (1 ≤ l ≤ r ≤ n), the beginning and the end of the subsegment chosen respectively.
If there are several possible answers you may output any of them.
Examples
Input
5
1 1 2 2 1
Output
1 5
Input
5
1 2 2 3 1
Output
2 3
Input
6
1 2 2 1 1 2
Output
1 5
Note
A subsegment B of an array A from l to r is an array of size r - l + 1 where Bi = Al + i - 1 for all 1 ≤ i ≤ r - l + 1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 1, -1, 0};
int dy[] = {1, 0, 0, -1};
long double PI = 3.14159265358979323846264338327950;
const int N = 1e6 + 10;
int st[N], End[N], mp[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
int a[n];
for (int i = 1; i <= n; i++) {
cin >> a[i];
mp[a[i]]++;
End[a[i]] = i;
if (!st[a[i]]) st[a[i]] = i;
}
int l, r, mx = 0;
for (int i = 0; i < N; i++) {
if (mp[i]) {
if (mp[i] > mx) {
mx = mp[i];
l = st[i];
r = End[i];
} else if (mp[i] == mx) {
if (End[i] - st[i] < r - l) {
l = st[i];
r = End[i];
}
}
}
}
cout << l << " " << r;
return 0;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
There are N cubes stacked vertically on a desk.
You are given a string S of length N. The color of the i-th cube from the bottom is red if the i-th character in S is `0`, and blue if that character is `1`.
You can perform the following operation any number of times: choose a red cube and a blue cube that are adjacent, and remove them. Here, the cubes that were stacked on the removed cubes will fall down onto the object below them.
At most how many cubes can be removed?
Constraints
* 1 \leq N \leq 10^5
* |S| = N
* Each character in S is `0` or `1`.
Input
Input is given from Standard Input in the following format:
S
Output
Print the maximum number of cubes that can be removed.
Examples
Input
0011
Output
4
Input
11011010001011
Output
12
Input
0
Output
0
### Response
```cpp
#include<iostream>
using namespace std;
int x;
string s;
int main()
{
cin>>s;
for(int i=0;i<s.size();i++)
if(s[i]=='0')
x++;
cout<<2*min(x,(int)s.size()-x);
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
We're giving away nice huge bags containing number tiles! A bag we want to present to you contains n tiles. Each of them has a single number written on it — either 1 or 2.
However, there is one condition you must fulfill in order to receive the prize. You will need to put all the tiles from the bag in a sequence, in any order you wish. We will then compute the sums of all prefixes in the sequence, and then count how many of these sums are prime numbers. If you want to keep the prize, you will need to maximize the number of primes you get.
Can you win the prize? Hurry up, the bags are waiting!
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the number of number tiles in the bag. The following line contains n space-separated integers a_1, a_2, ..., a_n (a_i ∈ \{1, 2\}) — the values written on the tiles.
Output
Output a permutation b_1, b_2, ..., b_n of the input sequence (a_1, a_2, ..., a_n) maximizing the number of the prefix sums being prime numbers. If there are multiple optimal permutations, output any.
Examples
Input
5
1 2 1 2 1
Output
1 1 1 2 2
Input
9
1 1 2 1 1 1 2 1 1
Output
1 1 1 2 1 1 1 2 1
Note
The first solution produces the prefix sums 1, \mathbf{\color{blue}{2}}, \mathbf{\color{blue}{3}}, \mathbf{\color{blue}{5}}, \mathbf{\color{blue}{7}} (four primes constructed), while the prefix sums in the second solution are 1, \mathbf{\color{blue}{2}}, \mathbf{\color{blue}{3}}, \mathbf{\color{blue}{5}}, 6, \mathbf{\color{blue}{7}}, 8, 10, \mathbf{\color{blue}{11}} (five primes). Primes are marked bold and blue. In each of these cases, the number of produced primes is maximum possible.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int N = 1e6 + 4;
int main() {
int n;
scanf("%d", &n);
int one = 0, two = 0;
for (int i = 0; i < n; i++) {
int temp;
scanf("%d", &temp);
if (temp == 1)
one++;
else
two++;
}
if (two) {
cout << "2 ";
two--;
if (one) {
cout << "1 ";
one--;
}
while (two--) cout << "2 ";
while (one > 0) {
cout << "1 ";
one--;
}
} else {
while (one--) cout << "1 ";
}
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
Little Petya has recently started attending a programming club. Naturally he is facing the problem of choosing a programming language. After long considerations he realized that Java is the best choice. The main argument in favor of choosing Java was that it has a very large integer data type, called BigInteger.
But having attended several classes of the club, Petya realized that not all tasks require using the BigInteger type. It turned out that in some tasks it is much easier to use small data types. That's why a question arises: "Which integer type to use if one wants to store a positive integer n?"
Petya knows only 5 integer types:
1) byte occupies 1 byte and allows you to store numbers from - 128 to 127
2) short occupies 2 bytes and allows you to store numbers from - 32768 to 32767
3) int occupies 4 bytes and allows you to store numbers from - 2147483648 to 2147483647
4) long occupies 8 bytes and allows you to store numbers from - 9223372036854775808 to 9223372036854775807
5) BigInteger can store any integer number, but at that it is not a primitive type, and operations with it are much slower.
For all the types given above the boundary values are included in the value range.
From this list, Petya wants to choose the smallest type that can store a positive integer n. Since BigInteger works much slower, Peter regards it last. Help him.
Input
The first line contains a positive number n. It consists of no more than 100 digits and doesn't contain any leading zeros. The number n can't be represented as an empty string.
Please, do not use %lld specificator to read or write 64-bit integers in C++. It is preffered to use cout (also you may use %I64d).
Output
Print the first type from the list "byte, short, int, long, BigInteger", that can store the natural number n, in accordance with the data given above.
Examples
Input
127
Output
byte
Input
130
Output
short
Input
123456789101112131415161718192021222324
Output
BigInteger
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
string s;
int main() {
cin >> s;
if (s.size() > 19)
cout << "BigInteger" << endl;
else if (s.size() == 19) {
if (s <= "9223372036854775807")
cout << "long" << endl;
else
cout << "BigInteger" << endl;
} else {
long long n = 0;
for (int i = 0; i < s.size(); i++) n = n * 10 + s[i] - '0';
if (n > 2147483647)
cout << "long" << endl;
else if (n > 32767)
cout << "int" << endl;
else if (n > 127)
cout << "short" << endl;
else
cout << "byte" << endl;
}
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
Anya and Kirill are doing a physics laboratory work. In one of the tasks they have to measure some value n times, and then compute the average value to lower the error.
Kirill has already made his measurements, and has got the following integer values: x1, x2, ..., xn. It is important that the values are close to each other, namely, the difference between the maximum value and the minimum value is at most 2.
Anya does not want to make the measurements, however, she can't just copy the values from Kirill's work, because the error of each measurement is a random value, and this coincidence will be noted by the teacher. Anya wants to write such integer values y1, y2, ..., yn in her work, that the following conditions are met:
* the average value of x1, x2, ..., xn is equal to the average value of y1, y2, ..., yn;
* all Anya's measurements are in the same bounds as all Kirill's measurements, that is, the maximum value among Anya's values is not greater than the maximum value among Kirill's values, and the minimum value among Anya's values is not less than the minimum value among Kirill's values;
* the number of equal measurements in Anya's work and Kirill's work is as small as possible among options with the previous conditions met. Formally, the teacher goes through all Anya's values one by one, if there is equal value in Kirill's work and it is not strike off yet, he strikes off this Anya's value and one of equal values in Kirill's work. The number of equal measurements is then the total number of strike off values in Anya's work.
Help Anya to write such a set of measurements that the conditions above are met.
Input
The first line contains a single integer n (1 ≤ n ≤ 100 000) — the numeber of measurements made by Kirill.
The second line contains a sequence of integers x1, x2, ..., xn ( - 100 000 ≤ xi ≤ 100 000) — the measurements made by Kirill. It is guaranteed that the difference between the maximum and minimum values among values x1, x2, ..., xn does not exceed 2.
Output
In the first line print the minimum possible number of equal measurements.
In the second line print n integers y1, y2, ..., yn — the values Anya should write. You can print the integers in arbitrary order. Keep in mind that the minimum value among Anya's values should be not less that the minimum among Kirill's values, and the maximum among Anya's values should be not greater than the maximum among Kirill's values.
If there are multiple answers, print any of them.
Examples
Input
6
-1 1 1 0 0 -1
Output
2
0 0 0 0 0 0
Input
3
100 100 101
Output
3
101 100 100
Input
7
-10 -9 -10 -8 -10 -9 -9
Output
5
-10 -10 -9 -9 -9 -9 -9
Note
In the first example Anya can write zeros as here measurements results. The average value is then equal to the average value of Kirill's values, and there are only two equal measurements.
In the second example Anya should write two values 100 and one value 101 (in any order), because it is the only possibility to make the average be the equal to the average of Kirill's values. Thus, all three measurements are equal.
In the third example the number of equal measurements is 5.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
static const int MAXN = 1e5 + 10;
static const int OO = 0x3fffffff;
inline int read() {
int ret = 0, f = 1;
char c;
while (c = getchar(), !isdigit(c)) f = c == 45 ? -1 : 1;
while (isdigit(c)) {
ret = (ret << 3) + (ret << 1);
ret += c - 48;
c = getchar();
}
return f * ret;
}
map<int, int> vis;
vector<int> v;
vector<int> a;
int n;
int main() {
n = read();
for (int i = 1; i <= n; ++i) {
int x;
x = read();
if (vis[x]) {
++vis[x];
} else {
vis[x] = 1;
v.push_back(x);
}
a.push_back(x);
}
sort(v.begin(), v.end());
if (abs(v[v.size() - 1] - v[0]) != 2) {
printf("%d\n", a.size());
for (int i = 0; i < a.size(); ++i) {
printf("%d ", a[i]);
}
} else {
int num1 = vis[v[0]], num2 = vis[v[0] + 1], num3 = vis[v[v.size() - 1]];
int mi = min(num1, num3);
int mid = num2;
int c1 = num1 - mi, d1 = num3 - mi, e1 = num2 + mi * 2;
int mm = mid / 2;
int c2 = num1 + mm, d2 = num3 + mm, e2 = num2 - mm * 2;
int ans1, ans2, ans3, nb;
int same1 = num1 + num2 + num3 - mi * 2;
int same2 = num1 + num2 + num3 - mm * 2;
if (same1 > same2) {
ans1 = c2, ans2 = d2, ans3 = e2;
nb = same2;
} else {
ans1 = c1, ans2 = d1, ans3 = e1;
nb = same1;
}
printf("%d\n", nb);
for (int i = 1; i <= ans1; ++i) {
printf("%d ", v[0]);
}
for (int i = 1; i <= ans2; ++i) {
printf("%d ", v[v.size() - 1]);
}
for (int i = 1; i <= ans3; ++i) {
printf("%d ", v[0] + 1);
}
puts("");
}
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
Binary trees are defined recursively. A binary tree T is a structure defined on a finite set of nodes that either
* contains no nodes, or
* is composed of three disjoint sets of nodes:
- a root node.
- a binary tree called its left subtree.
- a binary tree called its right subtree.
Your task is to write a program which perform tree walks (systematically traverse all nodes in a tree) based on the following algorithms:
1. Print the root, the left subtree and right subtree (preorder).
2. Print the left subtree, the root and right subtree (inorder).
3. Print the left subtree, right subtree and the root (postorder).
Here, the given binary tree consists of n nodes and evey node has a unique ID from 0 to n-1.
Constraints
* 1 ≤ n ≤ 25
Input
The first line of the input includes an integer n, the number of nodes of the tree.
In the next n linen, the information of each node is given in the following format:
id left right
id is the node ID, left is ID of the left child and right is ID of the right child. If the node does not have the left (right) child, the left(right) is indicated by -1
Output
In the 1st line, print "Preorder", and in the 2nd line print a list of node IDs obtained by the preorder tree walk.
In the 3rd line, print "Inorder", and in the 4th line print a list of node IDs obtained by the inorder tree walk.
In the 5th line, print "Postorder", and in the 6th line print a list of node IDs obtained by the postorder tree walk.
Print a space character before each node ID.
Example
Input
9
0 1 4
1 2 3
2 -1 -1
3 -1 -1
4 5 8
5 6 7
6 -1 -1
7 -1 -1
8 -1 -1
Output
Preorder
0 1 2 3 4 5 6 7 8
Inorder
2 1 3 0 6 5 7 4 8
Postorder
2 3 1 6 7 5 8 4 0
### Response
```cpp
#include<bits/stdc++.h>
#define N 25
using namespace std;
int n,a[N],l[N],r[N];
bool used[N];
void dfs(int x,int z){
if(z==0)cout<<' '<<x;
if(l[x]!=-1)dfs(l[x],z);
if(z==1)cout<<' '<<x;
if(r[x]!=-1)dfs(r[x],z);
if(z==2)cout<<' '<<x;
}
int main(){
cin>>n;
for(int i=0;i<n;i++){
cin>>a[i];
cin>>l[a[i]]>>r[a[i]];
if(l[a[i]]!=-1)used[l[a[i]]]=true;
if(r[a[i]]!=-1)used[r[a[i]]]=true;
}
for(int i=0;i<n;i++)
if(!used[i])cout<<"Preorder"<<endl,dfs(i,0),cout<<endl;
for(int i=0;i<n;i++)
if(!used[i])cout<<"Inorder"<<endl,dfs(i,1),cout<<endl;
for(int i=0;i<n;i++)
if(!used[i])cout<<"Postorder"<<endl,dfs(i,2),cout<<endl;
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
Petya studies positional notations. He has already learned to add and subtract numbers in the systems of notations with different radices and has moved on to a more complicated action — multiplication. To multiply large numbers one has to learn the multiplication table. Unfortunately, in the second grade students learn only the multiplication table of decimals (and some students even learn it in the first grade). Help Petya make a multiplication table for numbers in the system of notations with the radix k.
Input
The first line contains a single integer k (2 ≤ k ≤ 10) — the radix of the system.
Output
Output the multiplication table for the system of notations with the radix k. The table must contain k - 1 rows and k - 1 columns. The element on the crossing of the i-th row and the j-th column is equal to the product of i and j in the system of notations with the radix k. Each line may have any number of spaces between the numbers (the extra spaces in the samples are put for clarity).
Examples
Input
10
Output
1 2 3 4 5 6 7 8 9
2 4 6 8 10 12 14 16 18
3 6 9 12 15 18 21 24 27
4 8 12 16 20 24 28 32 36
5 10 15 20 25 30 35 40 45
6 12 18 24 30 36 42 48 54
7 14 21 28 35 42 49 56 63
8 16 24 32 40 48 56 64 72
9 18 27 36 45 54 63 72 81
Input
3
Output
1 2
2 11
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void input() {}
void base(long long int a, long long int n) {
if (a / n > 0) cout << a / n;
cout << a % n << " ";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
input();
long long int n;
cin >> n;
long long int arr[n][n];
for (long long int i = 1; i < n; i++) {
for (long long int j = 1; j < n; j++) {
base(i * j, n);
}
cout << "\n";
}
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
Warawreh created a great company called Nanosoft. The only thing that Warawreh still has to do is to place a large picture containing its logo on top of the company's building.
The logo of Nanosoft can be described as four squares of the same size merged together into one large square. The top left square is colored with red, the top right square is colored with green, the bottom left square is colored with yellow and the bottom right square is colored with blue.
An Example of some correct logos:
<image>
An Example of some incorrect logos:
<image>
Warawreh went to Adhami's store in order to buy the needed picture. Although Adhami's store is very large he has only one picture that can be described as a grid of n rows and m columns. The color of every cell in the picture will be green (the symbol 'G'), red (the symbol 'R'), yellow (the symbol 'Y') or blue (the symbol 'B').
Adhami gave Warawreh q options, in every option he gave him a sub-rectangle from that picture and told him that he can cut that sub-rectangle for him. To choose the best option, Warawreh needs to know for every option the maximum area of sub-square inside the given sub-rectangle that can be a Nanosoft logo. If there are no such sub-squares, the answer is 0.
Warawreh couldn't find the best option himself so he asked you for help, can you help him?
Input
The first line of input contains three integers n, m and q (1 ≤ n , m ≤ 500, 1 ≤ q ≤ 3 ⋅ 10^{5}) — the number of row, the number columns and the number of options.
For the next n lines, every line will contain m characters. In the i-th line the j-th character will contain the color of the cell at the i-th row and j-th column of the Adhami's picture. The color of every cell will be one of these: {'G','Y','R','B'}.
For the next q lines, the input will contain four integers r_1, c_1, r_2 and c_2 (1 ≤ r_1 ≤ r_2 ≤ n, 1 ≤ c_1 ≤ c_2 ≤ m). In that option, Adhami gave to Warawreh a sub-rectangle of the picture with the upper-left corner in the cell (r_1, c_1) and with the bottom-right corner in the cell (r_2, c_2).
Output
For every option print the maximum area of sub-square inside the given sub-rectangle, which can be a NanoSoft Logo. If there are no such sub-squares, print 0.
Examples
Input
5 5 5
RRGGB
RRGGY
YYBBG
YYBBR
RBBRG
1 1 5 5
2 2 5 5
2 2 3 3
1 1 3 5
4 4 5 5
Output
16
4
4
4
0
Input
6 10 5
RRRGGGRRGG
RRRGGGRRGG
RRRGGGYYBB
YYYBBBYYBB
YYYBBBRGRG
YYYBBBYBYB
1 1 6 10
1 3 3 10
2 2 6 6
1 7 6 10
2 1 5 10
Output
36
4
16
16
16
Input
8 8 8
RRRRGGGG
RRRRGGGG
RRRRGGGG
RRRRGGGG
YYYYBBBB
YYYYBBBB
YYYYBBBB
YYYYBBBB
1 1 8 8
5 2 5 7
3 1 8 6
2 3 5 8
1 2 6 8
2 1 5 5
2 1 7 7
6 5 7 5
Output
64
0
16
4
16
4
36
0
Note
Picture for the first test:
<image>
The pictures from the left to the right corresponds to the options. The border of the sub-rectangle in the option is marked with black, the border of the sub-square with the maximal possible size, that can be cut is marked with gray.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 510, LOG = 10;
char grid[N][N];
int val[N][N], sum[N][N][4];
int st[N][N][LOG][LOG], lg[N];
int n, q, m, r1, c1, r2, c2, nr, nc;
string S = "RGYB";
int dr[4] = {0, 0, 1, 1};
int dc[4] = {0, 1, 0, 1};
inline bool check(int r1, int c1, int r2, int c2, int k) {
r1++, c1++, r2++, c2++;
return ((sum[r2][c2][k] - sum[r1 - 1][c2][k] - sum[r2][c1 - 1][k] +
sum[r1 - 1][c1 - 1][k]) == (r2 - r1 + 1) * (c2 - c1 + 1));
}
inline bool can(int r, int c, int s) {
if (r < 0 || c < 0) return false;
if (r + (s << 1) - 1 >= n || c + (s << 1) - 1 >= m) return false;
for (int i = 0; i < 4; i++) {
nr = r + dr[i] * s;
nc = c + dc[i] * s;
if (!check(nr, nc, nr + s - 1, nc + s - 1, i)) return false;
}
return true;
}
void build() {
lg[1] = 0;
for (int i = 2; i < N; i++) {
lg[i] = lg[i - 1];
if ((1 << (lg[i] + 1)) == i) lg[i]++;
}
for (int k = 1; k < LOG; k++) {
for (int i = 0; i + (1 << k) <= n; i++) {
for (int j = 0; j < m; j++) {
st[i][j][k][0] =
max(st[i][j][k - 1][0], st[i + (1 << (k - 1))][j][k - 1][0]);
}
}
}
for (int l = 1; l < LOG; l++) {
for (int k = 0; k < LOG; k++) {
for (int i = 0; i + (1 << k) <= n; i++) {
for (int j = 0; j + (1 << l) <= m; j++) {
st[i][j][k][l] =
max(st[i][j][k][l - 1], st[i][j + (1 << (l - 1))][k][l - 1]);
}
}
}
}
}
int a, b;
inline int getmax(int r1, int c1, int r2, int c2) {
if (r2 < r1 || c2 < c1 || r1 < 0 || r2 >= n || c1 < 0 || c2 >= m)
return -1000000010;
a = lg[(r2 - r1) + 1];
b = lg[(c2 - c1) + 1];
return max(max(st[r1][c1][a][b], st[r2 - (1 << a) + 1][c1][a][b]),
max(st[r1][c2 - (1 << b) + 1][a][b],
st[r2 - (1 << a) + 1][c2 - (1 << b) + 1][a][b]));
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 0; i < n; i++) {
scanf(" %s", grid[i]);
for (int j = 0; j < m; j++) {
for (int k = 0; k < 4; k++) {
sum[i + 1][j + 1][k] = sum[i][j + 1][k] + sum[i + 1][j][k] -
sum[i][j][k] + (S[k] == grid[i][j]);
}
}
}
int low, high, mid, res;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
low = 1, high = min(min(i + 1, n - i), min(j + 1, m - j));
while (high >= low) {
mid = ((low + high) >> 1);
if (can(i - mid + 1, j - mid + 1, mid))
st[i][j][0][0] = mid, low = mid + 1;
else
high = mid - 1;
}
}
}
build();
while (q--) {
scanf("%d%d%d%d", &r1, &c1, &r2, &c2);
r1--, c1--, r2--, c2--;
low = 1, high = (n >> 1), res = 0;
while (high >= low) {
mid = ((low + high) >> 1);
if (getmax(r1 + mid - 1, c1 + mid - 1, r2 - mid, c2 - mid) >= mid)
res = mid, low = mid + 1;
else
high = mid - 1;
}
printf("%d\n", res * res * 4);
}
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
We have a tree with N vertices. The vertices are numbered 0 through N - 1, and the i-th edge (0 ≤ i < N - 1) comnnects Vertex a_i and b_i. For each pair of vertices u and v (0 ≤ u, v < N), we define the distance d(u, v) as the number of edges in the path u-v.
It is expected that one of the vertices will be invaded by aliens from outer space. Snuke wants to immediately identify that vertex when the invasion happens. To do so, he has decided to install an antenna on some vertices.
First, he decides the number of antennas, K (1 ≤ K ≤ N). Then, he chooses K different vertices, x_0, x_1, ..., x_{K - 1}, on which he installs Antenna 0, 1, ..., K - 1, respectively. If Vertex v is invaded by aliens, Antenna k (0 ≤ k < K) will output the distance d(x_k, v). Based on these K outputs, Snuke will identify the vertex that is invaded. Thus, in order to identify the invaded vertex no matter which one is invaded, the following condition must hold:
* For each vertex u (0 ≤ u < N), consider the vector (d(x_0, u), ..., d(x_{K - 1}, u)). These N vectors are distinct.
Find the minumum value of K, the number of antennas, when the condition is satisfied.
Constraints
* 2 ≤ N ≤ 10^5
* 0 ≤ a_i, b_i < N
* The given graph is a tree.
Input
Input is given from Standard Input in the following format:
N
a_0 b_0
a_1 b_1
:
a_{N - 2} b_{N - 2}
Output
Print the minumum value of K, the number of antennas, when the condition is satisfied.
Examples
Input
5
0 1
0 2
0 3
3 4
Output
2
Input
2
0 1
Output
1
Input
10
2 8
6 0
4 1
7 6
2 3
8 6
6 9
2 4
5 8
Output
3
### Response
```cpp
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<vector>
#define SF scanf
#define PF printf
#define MAXN 100010
using namespace std;
vector<int> a[MAXN];
int n,root;
pair<int,int> dfs(int x,int fa){
int res=0,rs=0;
int flag=0;
for(int i=0;i<a[x].size();i++){
if(a[x][i]==fa)
continue;
pair<int,int> t=dfs(a[x][i],x);
int res1=t.first;
if(a[x].size()+(root==x)==2)
rs=t.second;
if(res1==0&&flag==1)
res++;
if(res1==0&&flag==0)
flag=1;
res+=res1;
}
return make_pair(res,max(rs,flag));
}
int main(){
SF("%d",&n);
int u,v;
for(int i=1;i<n;i++){
SF("%d%d",&u,&v);
a[u].push_back(v);
a[v].push_back(u);
}
for(int i=0;i<n;i++)
if(a[i].size()==1){
root=i;
break;
}
pair<int,int> ans=dfs(root,-1);
PF("%d",ans.first+ans.second);
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
Given a string t, we will call it unbalanced if and only if the length of t is at least 2, and more than half of the letters in t are the same. For example, both `voodoo` and `melee` are unbalanced, while neither `noon` nor `a` is.
You are given a string s consisting of lowercase letters. Determine if there exists a (contiguous) substring of s that is unbalanced. If the answer is positive, show a position where such a substring occurs in s.
Constraints
* 2 ≦ |s| ≦ 10^5
* s consists of lowercase letters.
Input
The input is given from Standard Input in the following format:
s
Output
If there exists no unbalanced substring of s, print `-1 -1`.
If there exists an unbalanced substring of s, let one such substring be s_a s_{a+1} ... s_{b} (1 ≦ a < b ≦ |s|), and print `a b`. If there exists more than one such substring, any of them will be accepted.
Examples
Input
needed
Output
2 5
Input
atcoder
Output
-1 -1
### Response
```cpp
#include <string>
#include <iostream>
#include <cstdio>
using namespace std;
string a,b,c,d,e,f,g,h;
int main() {
cin >> f;
for(int i=0;i<f.length();i++){
if (f[i]==f[i+1]) return printf("%d %d\n",i+1,i+2), 0;
}
for (int i = 0; i + 2 < f.length(); i++) {
if(f[i]==f[i+2]) return printf("%d %d\n",i+1,i+3), 0;
}
printf("-1 -1\n");
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Fibonacci number f(i) appear in a variety of puzzles in nature and math, including packing problems, family trees or Pythagorean triangles. They obey the rule f(i) = f(i - 1) + f(i - 2), where we set f(0) = 1 = f(-1).
Let V and d be two certain positive integers and be N ≡ 1001 a constant. Consider a set of V nodes, each node i having a Fibonacci label F[i] = (f(i) mod N) assigned for i = 1,..., V ≤ N. If |F(i) - F(j)| < d, then the nodes i and j are connected.
Given V and d, how many connected subsets of nodes will you obtain?
<image>
Figure 1: There are 4 connected subsets for V = 20 and d = 100.
Constraints
* 1 ≤ V ≤ 1000
* 1 ≤ d ≤ 150
Input
Each data set is defined as one line with two integers as follows:
Line 1: Number of nodes V and the distance d.
Input includes several data sets (i.e., several lines). The number of dat sets is less than or equal to 50.
Output
Output line contains one integer - the number of connected subsets - for each input line.
Example
Input
5 5
50 1
13 13
Output
2
50
8
### Response
```cpp
#include<iostream>
#include<vector>
#include<cstdlib>
#include<algorithm>
#define N 1001
using namespace std;
vector<int> fibo;
void makeFiboModN( int V ){
fibo.resize( V+1 );
fibo[0] = 1;
fibo[1] = 2;
for(int i = 2; i <= V; ++i){
fibo[i] = ( (fibo[i - 1]%N) + (fibo[i - 2]%N) ) % N;
}
}
int main(){
while(true){
int ans = 0;
int V,d;
cin>>V>>d;
if(cin.eof())break;
makeFiboModN( V );
sort(fibo.begin()+1,fibo.end());
for(int i = 1; i <= V-1; ++i){
if( abs( fibo[i] - fibo[i+1] ) < d ){
;
}else{
++ans;
}
}
cout << ans+1 << endl;
}
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
You might have remembered Theatre square from the [problem 1A](https://codeforces.com/problemset/problem/1/A). Now it's finally getting repaved.
The square still has a rectangular shape of n × m meters. However, the picture is about to get more complicated now. Let a_{i,j} be the j-th square in the i-th row of the pavement.
You are given the picture of the squares:
* if a_{i,j} = "*", then the j-th square in the i-th row should be black;
* if a_{i,j} = ".", then the j-th square in the i-th row should be white.
The black squares are paved already. You have to pave the white squares. There are two options for pavement tiles:
* 1 × 1 tiles — each tile costs x burles and covers exactly 1 square;
* 1 × 2 tiles — each tile costs y burles and covers exactly 2 adjacent squares of the same row. Note that you are not allowed to rotate these tiles or cut them into 1 × 1 tiles.
You should cover all the white squares, no two tiles should overlap and no black squares should be covered by tiles.
What is the smallest total price of the tiles needed to cover all the white squares?
Input
The first line contains a single integer t (1 ≤ t ≤ 500) — the number of testcases. Then the description of t testcases follow.
The first line of each testcase contains four integers n, m, x and y (1 ≤ n ≤ 100; 1 ≤ m ≤ 1000; 1 ≤ x, y ≤ 1000) — the size of the Theatre square, the price of the 1 × 1 tile and the price of the 1 × 2 tile.
Each of the next n lines contains m characters. The j-th character in the i-th line is a_{i,j}. If a_{i,j} = "*", then the j-th square in the i-th row should be black, and if a_{i,j} = ".", then the j-th square in the i-th row should be white.
It's guaranteed that the sum of n × m over all testcases doesn't exceed 10^5.
Output
For each testcase print a single integer — the smallest total price of the tiles needed to cover all the white squares in burles.
Example
Input
4
1 1 10 1
.
1 2 10 1
..
2 1 10 1
.
.
3 3 3 7
..*
*..
.*.
Output
10
1
20
18
Note
In the first testcase you are required to use a single 1 × 1 tile, even though 1 × 2 tile is cheaper. So the total price is 10 burles.
In the second testcase you can either use two 1 × 1 tiles and spend 20 burles or use a single 1 × 2 tile and spend 1 burle. The second option is cheaper, thus the answer is 1.
The third testcase shows that you can't rotate 1 × 2 tiles. You still have to use two 1 × 1 tiles for the total price of 20.
In the fourth testcase the cheapest way is to use 1 × 1 tiles everywhere. The total cost is 6 ⋅ 3 = 18.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int ts;
cin >> ts;
while (ts--) {
int n, m, c1, c2;
int i, j, k, l;
cin >> n >> m >> c1 >> c2;
string grid[111];
for (i = 0; i < n; i++) {
cin >> grid[i];
}
int cost = 0;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (grid[i][j] == '.') {
if (j + 1 < m) {
if (grid[i][j + 1] == '.') {
if (2 * c1 > c2) {
cost += c2;
j++;
} else {
cost += c1;
}
} else {
cost += c1;
}
} else {
cost += c1;
}
}
}
}
cout << cost << "\n";
}
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
The Hedgehog likes to give presents to his friend, but no less he likes to receive them.
Having received another present today, the Hedgehog suddenly understood that he has no place to put it as there was no room left on the special shelf in the cupboard. He will have to choose another shelf, but which one should he choose, how large should it be?
In order to get to know this, the Hedgehog asks you to write him a program that will count the estimated number of presents that he will receive during the following N days. Besides, he is guided by the principle:
* on each holiday day the Hedgehog will necessarily receive a present,
* he receives presents at least every K days (i.e., if he received a present on the i-th day, he will receive the next present no later than on the i + K-th day).
For the given N and K, as well as the list of holidays among the following N days count the minimal number of presents that could be given to the Hedgehog. The number of today's day is zero, and you should regard today's present as already given (i.e., you shouldn't count it in the answer).
Input
The first line contains integers N and K (1 ≤ N ≤ 365, 1 ≤ K ≤ N).
The second line contains a number C which represents the number of holidays (0 ≤ C ≤ N). Then in the same line follow C numbers ranging from 1 to N which are the numbers of holiday days. The numbers are given in the increasing order, without repeating numbers among them.
Output
Print a single number — the minimal number of presents the Hedgehog will receive over the following N days.
Examples
Input
5 2
1 3
Output
3
Input
10 1
3 6 7 8
Output
10
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, c;
cin >> n >> k >> c;
if (c == 0) {
cout << n / k;
return 0;
}
int a[c];
for (int i = 0; i < c; i++) cin >> a[i];
int ans = c;
int prev = 0;
if (a[0] > k) {
while (prev + k < a[0]) {
prev = prev + k;
ans++;
}
}
prev = a[0];
for (int i = 1; i < c; i++) {
if (prev + k < a[i]) {
prev = prev + k;
ans++;
i--;
continue;
} else
prev = a[i];
}
if (a[c - 1] + k <= n) {
while (a[c - 1] + k <= n) {
a[c - 1] = a[c - 1] + k;
ans++;
}
}
cout << ans;
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
Anna and Maria are in charge of the math club for junior students. When the club gathers together, the students behave badly. They've brought lots of shoe laces to the club and got tied with each other. Specifically, each string ties together two students. Besides, if two students are tied, then the lace connects the first student with the second one as well as the second student with the first one.
To restore order, Anna and Maria do the following. First, for each student Anna finds out what other students he is tied to. If a student is tied to exactly one other student, Anna reprimands him. Then Maria gathers in a single group all the students who have been just reprimanded. She kicks them out from the club. This group of students immediately leaves the club. These students takes with them the laces that used to tie them. Then again for every student Anna finds out how many other students he is tied to and so on. And they do so until Anna can reprimand at least one student.
Determine how many groups of students will be kicked out of the club.
Input
The first line contains two integers n and m — the initial number of students and laces (<image>). The students are numbered from 1 to n, and the laces are numbered from 1 to m. Next m lines each contain two integers a and b — the numbers of students tied by the i-th lace (1 ≤ a, b ≤ n, a ≠ b). It is guaranteed that no two students are tied with more than one lace. No lace ties a student to himself.
Output
Print the single number — the number of groups of students that will be kicked out from the club.
Examples
Input
3 3
1 2
2 3
3 1
Output
0
Input
6 3
1 2
2 3
3 4
Output
2
Input
6 5
1 4
2 4
3 4
5 4
6 4
Output
1
Note
In the first sample Anna and Maria won't kick out any group of students — in the initial position every student is tied to two other students and Anna won't be able to reprimand anyone.
In the second sample four students are tied in a chain and two more are running by themselves. First Anna and Maria kick out the two students from both ends of the chain (1 and 4), then — two other students from the chain (2 and 3). At that the students who are running by themselves will stay in the club.
In the third sample Anna and Maria will momentarily kick out all students except for the fourth one and the process stops at that point. The correct answer is one.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 111;
vector<int> v[200];
bool vis[200];
int cap[200];
int main() {
int n, m;
cin >> n >> m;
int a, b;
for (int i = 0; i < m; ++i) {
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
++cap[a], ++cap[b];
}
int ans = 0;
while (1) {
bool flag = 0;
memset(vis, 0, sizeof vis);
for (int i = 1; i <= n; ++i) {
if (!vis[i] && cap[i] == 1) {
flag = 1;
int node = v[i][0];
vector<int>::iterator it;
for (it = v[node].begin(); it != v[node].end(); ++it) {
if (*it == i) break;
}
v[node].erase(it);
vis[node] = 1;
--cap[node];
--cap[i];
}
}
if (!flag)
break;
else
++ans;
}
cout << ans << '\n';
return 0;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
Don't you tell me what you think that I can be
If you say that Arkady is a bit old-fashioned playing checkers, you won't be right. There is also a modern computer game Arkady and his friends are keen on. We won't discuss its rules, the only feature important to this problem is that each player has to pick a distinct hero in the beginning of the game.
There are 2 teams each having n players and 2n heroes to distribute between the teams. The teams take turns picking heroes: at first, the first team chooses a hero in its team, after that the second team chooses a hero and so on. Note that after a hero is chosen it becomes unavailable to both teams.
The friends estimate the power of the i-th of the heroes as p_i. Each team wants to maximize the total power of its heroes. However, there is one exception: there are m pairs of heroes that are especially strong against each other, so when any team chooses a hero from such a pair, the other team must choose the other one on its turn. Each hero is in at most one such pair.
This is an interactive problem. You are to write a program that will optimally choose the heroes for one team, while the jury's program will play for the other team. Note that the jury's program may behave inefficiently, in this case you have to take the opportunity and still maximize the total power of your team. Formally, if you ever have chance to reach the total power of q or greater regardless of jury's program choices, you must get q or greater to pass a test.
Input
The first line contains two integers n and m (1 ≤ n ≤ 10^3, 0 ≤ m ≤ n) — the number of players in one team and the number of special pairs of heroes.
The second line contains 2n integers p_1, p_2, …, p_{2n} (1 ≤ p_i ≤ 10^3) — the powers of the heroes.
Each of the next m lines contains two integer a and b (1 ≤ a, b ≤ 2n, a ≠ b) — a pair of heroes that are especially strong against each other. It is guaranteed that each hero appears at most once in this list.
The next line contains a single integer t (1 ≤ t ≤ 2) — the team you are to play for. If t = 1, the first turn is yours, otherwise you have the second turn.
Hacks
In order to hack, use the format described above with one additional line. In this line output 2n distinct integers from 1 to 2n — the priority order for the jury's team. The jury's team will on each turn select the first possible hero from this list. Here possible means that it is not yet taken and does not contradict the rules about special pair of heroes.
Interaction
When it is your turn, print a single integer x (1 ≤ x ≤ 2n) — the index of the hero chosen by you. Note that you can't choose a hero previously chosen by either you of the other player, and you must follow the rules about special pairs of heroes.
When it is the other team's turn, read a line containing a single integer x (1 ≤ x ≤ 2n) — the index of the hero chosen by the other team. It is guaranteed that this index is not chosen before and that the other team also follows the rules about special pairs of heroes.
After the last turn you should terminate without printing anything.
After printing your choice do not forget to output end of line and flush the output. Otherwise you will get Idleness limit exceeded. To do this, use:
* fflush(stdout) or cout.flush() in C++;
* System.out.flush() in Java;
* flush(output) in Pascal;
* stdout.flush() in Python;
* see documentation for other languages.
Jury's answer -1 instead of a valid choice means that you made an invalid turn. Exit immediately after receiving -1 and you will see Wrong answer verdict. Otherwise you can get an arbitrary verdict because your solution will continue to read from a closed stream.
Examples
Input
3 1
1 2 3 4 5 6
2 6
1
2
4
1
Output
6
5
3
Input
3 1
1 2 3 4 5 6
1 5
2
6
1
3
Output
5
4
2
Note
In the first example the first turn is yours. In example, you choose 6, the other team is forced to reply with 2. You choose 5, the other team chooses 4. Finally, you choose 3 and the other team choose 1.
In the second example you have the second turn. The other team chooses 6, you choose 5, forcing the other team to choose 1. Now you choose 4, the other team chooses 3 and you choose 2.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long L_MAX = 1e18 + 228;
int main() {
int n, m;
cin >> n >> m;
int nn = n;
vector<int> a(2 * n + 1);
vector<pair<int, int> > b(m);
for (int i = 1; i <= 2 * n; ++i) cin >> a[i];
for (int i = 0; i < m; ++i) cin >> b[i].first >> b[i].second;
int t;
cin >> t;
if (t == 1) {
for (int i = 0; i < m; ++i) {
if (a[b[i].second] > a[b[i].first])
cout << b[i].second << endl;
else
cout << b[i].first << endl;
a[b[i].second] = -1234567890;
a[b[i].first] = -1234567890;
cin >> t;
}
while (n - m > 0) {
int mn = -1234567890;
for (int i = 1; i <= 2 * nn; ++i) {
if (mn < a[i]) {
mn = a[i];
t = i;
}
}
cout << t << endl;
a[t] = -1234567890;
cin >> t;
a[t] = -1234567890;
n--;
}
return 0;
} else {
bool flag = true;
while (flag && n) {
cin >> t;
a[t] = -1234567890;
bool temp = false;
for (int i = 0; i < m; ++i) {
if (t == b[i].first) {
cout << b[i].second << endl;
a[b[i].second] = -1234567890;
temp = true;
} else if (t == b[i].second) {
cout << b[i].first << endl;
a[b[i].first] = -1234567890;
temp = true;
}
}
flag = temp;
n--;
}
if (flag == false) n++;
for (int i = 0; i < m; ++i) {
if (a[b[i].first] != -1234567890) {
if (a[b[i].second] > a[b[i].first])
cout << b[i].second << endl;
else
cout << b[i].first << endl;
n--;
a[b[i].second] = -1234567890;
a[b[i].first] = -1234567890;
cin >> t;
}
}
while (n) {
int mn = -1234567890;
for (int i = 1; i <= 2 * nn; ++i) {
if (mn < a[i]) {
mn = a[i];
t = i;
}
}
cout << t << endl;
a[t] = -1234567890;
n--;
if (n == 0) return 0;
cin >> t;
a[t] = -1234567890;
}
}
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
You are given n segments on a number line; each endpoint of every segment has integer coordinates. Some segments can degenerate to points. Segments can intersect with each other, be nested in each other or even coincide.
The intersection of a sequence of segments is such a maximal set of points (not necesserily having integer coordinates) that each point lies within every segment from the sequence. If the resulting set isn't empty, then it always forms some continuous segment. The length of the intersection is the length of the resulting segment or 0 in case the intersection is an empty set.
For example, the intersection of segments [1;5] and [3;10] is [3;5] (length 2), the intersection of segments [1;5] and [5;7] is [5;5] (length 0) and the intersection of segments [1;5] and [6;6] is an empty set (length 0).
Your task is to remove exactly one segment from the given sequence in such a way that the intersection of the remaining (n - 1) segments has the maximal possible length.
Input
The first line contains a single integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the number of segments in the sequence.
Each of the next n lines contains two integers l_i and r_i (0 ≤ l_i ≤ r_i ≤ 10^9) — the description of the i-th segment.
Output
Print a single integer — the maximal possible length of the intersection of (n - 1) remaining segments after you remove exactly one segment from the sequence.
Examples
Input
4
1 3
2 6
0 4
3 3
Output
1
Input
5
2 6
1 3
0 4
1 20
0 4
Output
2
Input
3
4 5
1 2
9 20
Output
0
Input
2
3 10
1 5
Output
7
Note
In the first example you should remove the segment [3;3], the intersection will become [2;3] (length 1). Removing any other segment will result in the intersection [3;3] (length 0).
In the second example you should remove the segment [1;3] or segment [2;6], the intersection will become [2;4] (length 2) or [1;3] (length 2), respectively. Removing any other segment will result in the intersection [2;3] (length 1).
In the third example the intersection will become an empty set no matter the segment you remove.
In the fourth example you will get the intersection [3;10] (length 7) if you remove the segment [1;5] or the intersection [1;5] (length 4) if you remove the segment [3;10].
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, max1 = -1, min1 = 2000000000, nrmax, nrmin, max2 = -1, min2 = 2000000000,
l, r, dim, maxi;
int E[300000 + 5];
struct PUNCT {
int l, r;
} X[300000 + 5];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> X[i].l >> X[i].r;
if (X[i].l > max2) {
if (X[i].l > max1) {
max2 = max1;
max1 = X[i].l;
nrmax = 1;
} else {
if (X[i].l == max1)
nrmax++;
else
max2 = X[i].l;
}
}
if (X[i].r < min2) {
if (X[i].r < min1) {
min2 = min1;
min1 = X[i].r;
nrmin = 1;
} else {
if (X[i].r == min1)
nrmin++;
else
min2 = X[i].r;
}
}
}
for (int i = 1; i <= n; i++) {
if (X[i].l == max1) {
if (nrmax > 1)
l = max1;
else
l = max2;
} else
l = max1;
if (X[i].r == min1) {
if (nrmin > 1)
r = min1;
else
r = min2;
} else
r = min1;
dim = r - l;
maxi = max(maxi, dim);
}
cout << maxi;
return 0;
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
A coordinate line has n segments, the i-th segment starts at the position li and ends at the position ri. We will denote such a segment as [li, ri].
You have suggested that one of the defined segments covers all others. In other words, there is such segment in the given set, which contains all other ones. Now you want to test your assumption. Find in the given set the segment which covers all other segments, and print its number. If such a segment doesn't exist, print -1.
Formally we will assume that segment [a, b] covers segment [c, d], if they meet this condition a ≤ c ≤ d ≤ b.
Input
The first line contains integer n (1 ≤ n ≤ 105) — the number of segments. Next n lines contain the descriptions of the segments. The i-th line contains two space-separated integers li, ri (1 ≤ li ≤ ri ≤ 109) — the borders of the i-th segment.
It is guaranteed that no two segments coincide.
Output
Print a single integer — the number of the segment that covers all other segments in the set. If there's no solution, print -1.
The segments are numbered starting from 1 in the order in which they appear in the input.
Examples
Input
3
1 1
2 2
3 3
Output
-1
Input
6
1 5
2 3
1 10
7 10
7 7
10 10
Output
3
### Response
```cpp
#include <bits/stdc++.h>
int main() {
int n, a[100010], b[100010], x, y, z;
int i, j;
while (scanf("%d", &n) != EOF) {
scanf("%d %d", &a[0], &b[0]);
x = a[0];
y = b[0];
z = 1;
for (i = 1; i < n; i++) {
scanf("%d %d", &a[i], &b[i]);
if (a[i] <= x && b[i] >= y) {
x = a[i];
y = b[i];
z = (i + 1);
}
}
for (i = 0; i < n; i++) {
if (x > a[i] || y < b[i]) {
z = -1;
break;
}
}
printf("%d\n", z);
}
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
The statement of this problem is the same as the statement of problem C1. The only difference is that, in problem C1, n is always even, and in C2, n is always odd.
You are given a regular polygon with 2 ⋅ n vertices (it's convex and has equal sides and equal angles) and all its sides have length 1. Let's name it as 2n-gon.
Your task is to find the square of the minimum size such that you can embed 2n-gon in the square. Embedding 2n-gon in the square means that you need to place 2n-gon in the square in such way that each point which lies inside or on a border of 2n-gon should also lie inside or on a border of the square.
You can rotate 2n-gon and/or the square.
Input
The first line contains a single integer T (1 ≤ T ≤ 200) — the number of test cases.
Next T lines contain descriptions of test cases — one per line. Each line contains single odd integer n (3 ≤ n ≤ 199). Don't forget you need to embed 2n-gon, not an n-gon.
Output
Print T real numbers — one per test case. For each test case, print the minimum length of a side of the square 2n-gon can be embedded in. Your answer will be considered correct if its absolute or relative error doesn't exceed 10^{-6}.
Example
Input
3
3
5
199
Output
1.931851653
3.196226611
126.687663595
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1);
int t, n;
signed main() {
cin >> t;
while (t--) {
cin >> n;
if (n == 2) {
printf("1.000000000\n");
} else {
double p = (n * 2 - 2) * pi / n / 2, minus = (pi - p) / 2.0, tmp = 1;
int tt;
if (n & 1)
tt = n / 2;
else
tt = n / 2 - 1;
for (int i = 1; i < tt; ++i)
tmp = sqrt(1 + tmp * tmp - 2 * tmp * cos(p)), p -= minus;
if (n & 1)
tmp += sqrt(1 + tmp * tmp - 2 * tmp * cos(p));
else
tmp *= 2;
printf("%.9lf\n", tmp / sqrt(2.0) + (n % 2 == 0));
}
}
return 0;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
Vasya has recently developed a new algorithm to optimize the reception of customer flow and he considered the following problem.
Let the queue to the cashier contain n people, at that each of them is characterized by a positive integer ai — that is the time needed to work with this customer. What is special about this very cashier is that it can serve two customers simultaneously. However, if two customers need ai and aj of time to be served, the time needed to work with both of them customers is equal to max(ai, aj). Please note that working with customers is an uninterruptable process, and therefore, if two people simultaneously come to the cashier, it means that they begin to be served simultaneously, and will both finish simultaneously (it is possible that one of them will have to wait).
Vasya used in his algorithm an ingenious heuristic — as long as the queue has more than one person waiting, then some two people of the first three standing in front of the queue are sent simultaneously. If the queue has only one customer number i, then he goes to the cashier, and is served within ai of time. Note that the total number of phases of serving a customer will always be equal to ⌈n / 2⌉.
Vasya thinks that this method will help to cope with the queues we all hate. That's why he asked you to work out a program that will determine the minimum time during which the whole queue will be served using this algorithm.
Input
The first line of the input file contains a single number n (1 ≤ n ≤ 1000), which is the number of people in the sequence. The second line contains space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 106). The people are numbered starting from the cashier to the end of the queue.
Output
Print on the first line a single number — the minimum time needed to process all n people. Then on ⌈n / 2⌉ lines print the order in which customers will be served. Each line (probably, except for the last one) must contain two numbers separated by a space — the numbers of customers who will be served at the current stage of processing. If n is odd, then the last line must contain a single number — the number of the last served customer in the queue. The customers are numbered starting from 1.
Examples
Input
4
1 2 3 4
Output
6
1 2
3 4
Input
5
2 4 3 1 4
Output
8
1 3
2 5
4
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int INF = 500000001;
int cost[2][1001], path[3][501][1001], r[2][501];
int main() {
for (int n; ~scanf("%d", &n);) {
int m = n / 2;
vector<int> a(n + 2, INF);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
if (n == 1) {
printf("%d\n1\n", a[0]);
continue;
} else if (n == 2) {
printf("%d\n1 2\n", max(a[0], a[1]));
continue;
} else if (n == 3) {
int x = max(a[0], a[1]) + a[2];
int y = max(a[1], a[2]) + a[0];
int z = max(a[0], a[2]) + a[1];
if (x < y && x < z)
printf("%d\n1 2\n3\n", x);
else if (y < z)
printf("%d\n2 3\n1\n", y);
else
printf("%d\n1 3\n2\n", z);
continue;
}
for (int j = 0; j < 1001; ++j) {
for (int i = 0; i < 501; ++i)
path[0][i][j] = path[1][i][j] = path[2][i][j] = INF;
for (int i = 0; i < 2; ++i) cost[i][j] = INF;
}
for (int i = 0; i < 3; ++i) {
cost[0][i] = max(a[(i + 1) % 3], a[(i + 2) % 3]);
path[0][0][i] = (i + 1) % 3;
path[1][0][i] = (i + 2) % 3;
path[2][0][i] = i;
}
for (int i = 1; i < m; ++i) {
int now = i & 1;
int p = 3 + 2 * (i - 1);
for (int j = 0; j < n; ++j) {
if (cost[!now][j] != INF) {
int x = cost[!now][j] + max(a[p], a[p + 1]);
int y = cost[!now][j] + max(a[j], a[p + 1]);
int z = cost[!now][j] + max(a[j], a[p]);
if (x < cost[now][j]) {
cost[now][j] = x;
path[0][i][j] = p;
path[1][i][j] = p + 1;
path[2][i][j] = j;
}
if (y < cost[now][p]) {
cost[now][p] = y;
path[0][i][p] = j;
path[1][i][p] = p + 1;
path[2][i][p] = j;
}
if (z < cost[now][p + 1]) {
cost[now][p + 1] = z;
path[0][i][p + 1] = j;
path[1][i][p + 1] = p;
path[2][i][p + 1] = j;
}
}
cost[!now][j] = INF;
}
}
int result = INF, index = 0;
for (int i = 0; i < 1001; ++i)
if (cost[!(m & 1)][i] != INF) {
int c = cost[!(m & 1)][i] + a[i] * (n & 1);
if (c < INF && c < result) {
result = c;
index = i;
}
}
printf("%d\n", result);
int pre = index;
for (int i = 0; i < m; ++i) {
r[0][m - i - 1] = path[0][m - i - 1][pre] + 1;
r[1][m - i - 1] = path[1][m - i - 1][pre] + 1;
pre = path[2][m - i - 1][pre];
}
for (int i = 0; i < m; ++i) printf("%d %d\n", r[0][i], r[1][i]);
if (n & 1) printf("%d\n", index + 1);
}
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
You've got a table of size n × m. We'll consider the table rows numbered from top to bottom 1 through n, and the columns numbered from left to right 1 through m. Then we'll denote the cell in row x and column y as (x, y).
Initially cell (1, 1) contains two similar turtles. Both turtles want to get to cell (n, m). Some cells of the table have obstacles but it is guaranteed that there aren't any obstacles in the upper left and lower right corner. A turtle (one or the other) can go from cell (x, y) to one of two cells (x + 1, y) and (x, y + 1), as long as the required cell doesn't contain an obstacle. The turtles have had an argument so they don't want to have any chance of meeting each other along the way. Help them find the number of ways in which they can go from cell (1, 1) to cell (n, m).
More formally, find the number of pairs of non-intersecting ways from cell (1, 1) to cell (n, m) modulo 1000000007 (109 + 7). Two ways are called non-intersecting if they have exactly two common points — the starting point and the final point.
Input
The first line contains two integers n, m (2 ≤ n, m ≤ 3000). Each of the following n lines contains m characters describing the table. The empty cells are marked by characters ".", the cells with obstacles are marked by "#".
It is guaranteed that the upper left and the lower right cells are empty.
Output
In a single line print a single integer — the number of pairs of non-intersecting paths from cell (1, 1) to cell (n, m) modulo 1000000007 (109 + 7).
Examples
Input
4 5
.....
.###.
.###.
.....
Output
1
Input
2 3
...
...
Output
1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int N = 3333;
long long dp0[N][N], dp1[N][N];
char s[N][N];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%s", s[i] + 1);
dp0[1][2] = 1;
dp1[2][1] = 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (s[i][j] != '#') {
if (i != 1 && s[i - 1][j] == '.')
dp0[i][j] += dp0[i - 1][j], dp1[i][j] += dp1[i - 1][j];
if (j != 1 && s[i][j - 1] == '.')
dp0[i][j] += dp0[i][j - 1], dp1[i][j] += dp1[i][j - 1];
dp0[i][j] %= MOD;
dp1[i][j] %= MOD;
}
cout << (dp0[n - 1][m] * dp1[n][m - 1] - dp0[n][m - 1] * dp1[n - 1][m] +
MOD * MOD) %
MOD
<< endl;
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
One day a well-known sponsor of a well-known contest decided to give every participant of the contest a T-shirt as a present. A natural problem occurred: on the one hand, it is not clear how many T-shirts of what sizes should be ordered, and on the other hand, one doesn't want to order too many T-shirts (and we do not exactly paper the walls with the oversupply). After considerable brain racking and some pre-estimating, the sponsor representatives ordered a certain number of T-shirts of sizes S, M, L, XL and XXL. The T-shirts turned out to bring good luck, that's why on the contest day there built up a line of K participants willing to get one. Every contestant is characterized by his/her desired T-shirt size (so it happens that for all the participants it is also one of the sizes S, M, L, XL and XXL). The participants come up to get a T-shirt one by one and try to choose the most suitable one, choosing it like this. If there is still a T-shirt of the optimal size left, that he/she takes it without further ado. Otherwise the contestant would prefer to choose a T-shirt with the size as close to the optimal one as possible (the distance between neighboring sizes is considered equal to one). If the variant of choice is not unique, the contestant will take a T-shirt of a bigger size (in case he/she grows more). For example, for a person whose optimal size is L the preference list looks like this: L, XL, M, XXL, S. Using the data on how many T-shirts of every size had been ordered by the organizers, on the size of contestants in the line determine who got a T-shirt of what size.
Input
The first line contains five non-negative integers NS, NM, NL, NXL, NXXL not exceeding 1000 which represent the number of T-shirts of the corresponding sizes. The second line contains an integer K (1 ≤ K ≤ 1000) which represents the number of participants. The next K lines contain the optimal T-shirt sizes for the contestants. The sizes are given in the order in which the participants stand in the line. It is guaranteed that NS + NM + NL + NXL + NXXL ≥ K.
Output
For each contestant, print a line containing the size of the T-shirt he/she got.
Examples
Input
1 0 2 0 1
3
XL
XXL
M
Output
XXL
L
L
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int a[5], t;
string e[5] = {"S", "M", "L", "XL", "XXL"}, s;
int p() {
if (s == "S") return 0;
if (s == "M") return 1;
if (s == "L") return 2;
if (s == "XL") return 3;
if (s == "XXL") return 4;
}
int main() {
for (int i = (0); i < (5); i++) cin >> a[i];
cin >> t;
while (t--) {
cin >> s;
int x = p();
for (int i = (0); i < (5); i++) {
if (x + i < 5 && a[x + i] > 0) {
x += i;
break;
}
if (x - i >= 0 && a[x - i] > 0) {
x -= i;
break;
}
}
cout << e[x] << endl;
a[x]--;
}
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
You are given an array a of length 2n. Consider a partition of array a into two subsequences p and q of length n each (each element of array a should be in exactly one subsequence: either in p or in q).
Let's sort p in non-decreasing order, and q in non-increasing order, we can denote the sorted versions by x and y, respectively. Then the cost of a partition is defined as f(p, q) = ∑_{i = 1}^n |x_i - y_i|.
Find the sum of f(p, q) over all correct partitions of array a. Since the answer might be too big, print its remainder modulo 998244353.
Input
The first line contains a single integer n (1 ≤ n ≤ 150 000).
The second line contains 2n integers a_1, a_2, …, a_{2n} (1 ≤ a_i ≤ 10^9) — elements of array a.
Output
Print one integer — the answer to the problem, modulo 998244353.
Examples
Input
1
1 4
Output
6
Input
2
2 1 2 1
Output
12
Input
3
2 2 2 2 2 2
Output
0
Input
5
13 8 35 94 9284 34 54 69 123 846
Output
2588544
Note
Two partitions of an array are considered different if the sets of indices of elements included in the subsequence p are different.
In the first example, there are two correct partitions of the array a:
1. p = [1], q = [4], then x = [1], y = [4], f(p, q) = |1 - 4| = 3;
2. p = [4], q = [1], then x = [4], y = [1], f(p, q) = |4 - 1| = 3.
In the second example, there are six valid partitions of the array a:
1. p = [2, 1], q = [2, 1] (elements with indices 1 and 2 in the original array are selected in the subsequence p);
2. p = [2, 2], q = [1, 1];
3. p = [2, 1], q = [1, 2] (elements with indices 1 and 4 are selected in the subsequence p);
4. p = [1, 2], q = [2, 1];
5. p = [1, 1], q = [2, 2];
6. p = [2, 1], q = [2, 1] (elements with indices 3 and 4 are selected in the subsequence p).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long poww(long long x, long long y, long long m) {
x = x % m;
if (y == 0) {
return 1;
}
if (y % 2 == 0) {
return poww(x * x, y / 2, m);
} else {
return (x * poww(x * x, y / 2, m)) % m;
}
}
void io();
const int mod = 998244353;
const int maxn = 300000 + 10;
int n;
long long a[maxn];
long long fact[maxn];
int main() {
io();
int i, j;
fact[0] = 1;
cin >> n;
for (long long i = 1; i <= 2 * n; i++) {
fact[i] = fact[i - 1] * i;
fact[i] %= mod;
}
for ((i) = 0; (i) < (2 * n); i = i + 1) cin >> a[i];
sort(a, a + 2 * n);
long long second = 0;
for ((i) = n; (i) < (2 * n); i = i + 1) second += a[i];
for ((i) = 0; (i) < (n); i = i + 1) second -= a[i];
second %= mod;
long long c1 = fact[2 * n];
long long c2 = (fact[n] * fact[n]) % mod;
c2 = poww(c2, mod - 2, mod) % mod;
long long c3 = (c1 * c2) % mod;
long long ans = (c3 * second) % mod;
cout << ans;
return 0;
}
void io() {}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
Innokenty is a president of a new football league in Byteland. The first task he should do is to assign short names to all clubs to be shown on TV next to the score. Of course, the short names should be distinct, and Innokenty wants that all short names consist of three letters.
Each club's full name consist of two words: the team's name and the hometown's name, for example, "DINAMO BYTECITY". Innokenty doesn't want to assign strange short names, so he wants to choose such short names for each club that:
1. the short name is the same as three first letters of the team's name, for example, for the mentioned club it is "DIN",
2. or, the first two letters of the short name should be the same as the first two letters of the team's name, while the third letter is the same as the first letter in the hometown's name. For the mentioned club it is "DIB".
Apart from this, there is a rule that if for some club x the second option of short name is chosen, then there should be no club, for which the first option is chosen which is the same as the first option for the club x. For example, if the above mentioned club has short name "DIB", then no club for which the first option is chosen can have short name equal to "DIN". However, it is possible that some club have short name "DIN", where "DI" are the first two letters of the team's name, and "N" is the first letter of hometown's name. Of course, no two teams can have the same short name.
Help Innokenty to choose a short name for each of the teams. If this is impossible, report that. If there are multiple answer, any of them will suit Innokenty. If for some team the two options of short name are equal, then Innokenty will formally think that only one of these options is chosen.
Input
The first line contains a single integer n (1 ≤ n ≤ 1000) — the number of clubs in the league.
Each of the next n lines contains two words — the team's name and the hometown's name for some club. Both team's name and hometown's name consist of uppercase English letters and have length at least 3 and at most 20.
Output
It it is not possible to choose short names and satisfy all constraints, print a single line "NO".
Otherwise, in the first line print "YES". Then print n lines, in each line print the chosen short name for the corresponding club. Print the clubs in the same order as they appeared in input.
If there are multiple answers, print any of them.
Examples
Input
2
DINAMO BYTECITY
FOOTBALL MOSCOW
Output
YES
DIN
FOO
Input
2
DINAMO BYTECITY
DINAMO BITECITY
Output
NO
Input
3
PLAYFOOTBALL MOSCOW
PLAYVOLLEYBALL SPB
GOGO TECHNOCUP
Output
YES
PLM
PLS
GOG
Input
3
ABC DEF
ABC EFG
ABD OOO
Output
YES
ABD
ABE
ABO
Note
In the first sample Innokenty can choose first option for both clubs.
In the second example it is not possible to choose short names, because it is not possible that one club has first option, and the other has second option if the first options are equal for both clubs.
In the third example Innokenty can choose the second options for the first two clubs, and the first option for the third club.
In the fourth example note that it is possible that the chosen short name for some club x is the same as the first option of another club y if the first options of x and y are different.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 2005, M = N * N;
bool vis[N];
char s[N][2][25];
int n, m, dfn[N], low[N], tt, S[N], col[N];
int hd[N], V[M], nx[M], fs[N], q[N], id[N], in[N];
vector<int> e[N];
void add(int u, int v) {
nx[++tt] = hd[u];
V[hd[u] = tt] = v;
}
void tarjan(int x) {
dfn[x] = low[x] = ++tt;
S[++S[0]] = x;
vis[x] = 1;
for (int i = hd[x]; i; i = nx[i]) {
if (!dfn[V[i]])
tarjan(V[i]), low[x] = min(low[x], low[V[i]]);
else if (vis[V[i]])
low[x] = min(low[x], dfn[V[i]]);
}
if (dfn[x] == low[x]) {
col[x] = ++col[0];
while (S[S[0]] != x) vis[S[S[0]]] = 0, col[S[S[0]--]] = col[0];
S[0]--;
vis[x] = 0;
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%s%s", s[i][0], s[i][1]);
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++) {
bool J = 1;
for (int k = 0; k < 3; k++) J &= (s[i][0][k] == s[j][0][k]);
if (J) add(i, i + n), add(j, j + n);
J = (s[i][1][0] == s[j][1][0]);
for (int k = 0; k < 2; k++) J &= (s[i][0][k] == s[j][0][k]);
if (J) add(i + n, j), add(j + n, i);
J = (s[i][0][2] == s[j][1][0]);
for (int k = 0; k < 2; k++) J &= (s[i][0][k] == s[j][0][k]);
if (J) add(i, j), add(j + n, i + n);
J = (s[i][1][0] == s[j][0][2]);
for (int k = 0; k < 2; k++) J &= (s[i][0][k] == s[j][0][k]);
if (J) add(j, i), add(i + n, j + n);
}
tt = 0;
for (int i = 1; i <= n + n; i++)
if (!dfn[i]) tarjan(i);
for (int i = 1; i <= n; i++)
if (col[i] == col[i + n]) {
puts("NO");
return 0;
}
puts("YES");
for (int i = 1; i <= n + n; i++)
for (int j = hd[i]; j; j = nx[j])
if (col[V[j]] != col[i]) e[col[i]].push_back(col[V[j]]), in[col[V[j]]]++;
int l = 1, r = 0;
for (int i = 1; i <= col[0]; i++)
if (!in[i]) q[id[i] = ++r] = i;
while (l <= r) {
int x = q[l++], z = e[x].size();
for (int v, i = 0; i < z; i++)
if (!(--in[v = e[x][i]])) q[id[v] = ++r] = v;
}
for (int i = 1; i <= n; i++) {
if (id[col[i]] < id[col[i + n]]) s[i][0][2] = s[i][1][0];
for (int k = 0; k < 3; k++) putchar(s[i][0][k]);
puts("");
}
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
This contest, AtCoder Beginner Contest, is abbreviated as ABC.
When we refer to a specific round of ABC, a three-digit number is appended after ABC. For example, ABC680 is the 680th round of ABC.
What is the abbreviation for the N-th round of ABC? Write a program to output the answer.
Constraints
* 100 ≤ N ≤ 999
Input
Input is given from Standard Input in the following format:
N
Output
Print the abbreviation for the N-th round of ABC.
Examples
Input
100
Output
ABC100
Input
425
Output
ABC425
Input
999
Output
ABC999
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string A;
cin >> A;
cout << "ABC"+A << endl;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
Professor Bajtocy is conducting experiments on alien DNA. He has discovered that it is subject to repetitive mutations — each mutation happens in the same way: some continuous subsequence of the alien DNA becomes active, copies itself, the copy gets mangled and inserts itself right after the original subsequence. The mangled copy of the activated continuous subsequence is formed by first joining all the elements at the even positions in that subsequence, and then joining all the elements at the odd ones at the end. That is, if the activated subsequence consists of 11 elements and represented as s1s2... s11, its mangled copy is s2s4s6s8s10s1s3s5s7s9s11.
For example, if the original sequence was "ACTGG" and the mutation happened on the segment [2, 4] (that is the activated subsequence is "CTG"), the mutated DNA is: "ACTGTCGG". The mangled copy of the activated subsequence is marked with bold font.
Professor Bajtocy has written down the original DNA sequence and the mutations that sequentially happened to it, and he now asks you to recover the first k elements of the DNA sequence after all the mutations.
Input
The first line of input contains the original DNA sequence, consisting only of letters "A", "C", "T" and "G" and not exceeding 3·106 in length.
The second line contains a single integer k (1 ≤ k ≤ 3·106).
The third line contains a single integer n (0 ≤ n ≤ 5000) — the number of mutations. The next n lines describe the mutations in chronological order — each mutation is described by two numbers li and ri (1 ≤ li ≤ ri ≤ 109), meaning that the continuous subsequence [li, ri] has become active and cloned itself, joining itself with the mangled copy.
It is guaranteed that the input data is correct, that is, no mutation acts on non-existing elements of the DNA sequence, and the resulting DNA sequence has at least k elements.
Assume that the DNA elements are indexed starting from 1 and that the notation [l, r] meaning the continuous subsequence of DNA sequence that consists of r - l + 1 elements starting at the l-th DNA sequence element and ending at the r-th DNA sequence element.
Output
Output a single line, containing the first k letters of the mutated DNA sequence.
Examples
Input
GAGA
4
0
Output
GAGA
Input
ACGTACGT
16
2
1 2
2 8
Output
ACCAGTACCGACATCG
Note
In the second example, after the first mutation the sequence is "ACCAGTACGT". After the second mutation it's "ACCAGTACCGACATCGT".
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:36777216")
template <class T>
inline void RD(T &);
template <class T>
inline void OT(const T &);
template <class T>
inline T &_RD(T &x) {
RD(x);
return x;
}
inline int RD() {
int x;
return _RD(x);
}
inline void RF(double &x) { scanf("%lf", &x); }
inline double _RF(double &x) {
scanf("%lf", &x);
return x;
}
inline double RF() {
double x;
return _RF(x);
}
inline void RC(char &c) { scanf(" %c", &c); }
inline char _RC(char &c) {
scanf(" %c", &c);
return c;
}
inline char RC() {
char c;
return _RC(c);
}
inline void RS(char *s) { scanf("%s", s); }
template <class T0, class T1>
inline void RD(T0 &x0, T1 &x1) {
RD(x0), RD(x1);
}
template <class T0, class T1, class T2>
inline void RD(T0 &x0, T1 &x1, T2 &x2) {
RD(x0), RD(x1), RD(x2);
}
template <class T0, class T1, class T2, class T3>
inline void RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3) {
RD(x0), RD(x1), RD(x2), RD(x3);
}
template <class T0, class T1, class T2, class T3, class T4>
inline void RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4) {
RD(x0), RD(x1), RD(x2), RD(x3), RD(x4);
}
template <class T0, class T1, class T2, class T3, class T4, class T5>
inline void RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5) {
RD(x0), RD(x1), RD(x2), RD(x3), RD(x4), RD(x5);
}
template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
inline void RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5, T6 &x6) {
RD(x0), RD(x1), RD(x2), RD(x3), RD(x4), RD(x5), RD(x6);
}
template <class T0, class T1>
inline void OT(T0 &x0, T1 &x1) {
OT(x0), OT(x1);
}
template <class T0, class T1, class T2>
inline void OT(T0 &x0, T1 &x1, T2 &x2) {
OT(x0), OT(x1), OT(x2);
}
template <class T0, class T1, class T2, class T3>
inline void OT(T0 &x0, T1 &x1, T2 &x2, T3 &x3) {
OT(x0), OT(x1), OT(x2), OT(x3);
}
template <class T0, class T1, class T2, class T3, class T4>
inline void OT(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4) {
OT(x0), OT(x1), OT(x2), OT(x3), OT(x4);
}
template <class T0, class T1, class T2, class T3, class T4, class T5>
inline void OT(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5) {
OT(x0), OT(x1), OT(x2), OT(x3), OT(x4), OT(x5);
}
template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
inline void OT(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5, T6 &x6) {
OT(x0), OT(x1), OT(x2), OT(x3), OT(x4), OT(x5), OT(x6);
}
template <class T>
inline void RST(T &A) {
memset(A, 0, sizeof(A));
}
template <class T0, class T1>
inline void RST(T0 &A0, T1 &A1) {
RST(A0), RST(A1);
}
template <class T0, class T1, class T2>
inline void RST(T0 &A0, T1 &A1, T2 &A2) {
RST(A0), RST(A1), RST(A2);
}
template <class T0, class T1, class T2, class T3>
inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3) {
RST(A0), RST(A1), RST(A2), RST(A3);
}
template <class T0, class T1, class T2, class T3, class T4>
inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4) {
RST(A0), RST(A1), RST(A2), RST(A3), RST(A4);
}
template <class T0, class T1, class T2, class T3, class T4, class T5>
inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5) {
RST(A0), RST(A1), RST(A2), RST(A3), RST(A4), RST(A5);
}
template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6) {
RST(A0), RST(A1), RST(A2), RST(A3), RST(A4), RST(A5), RST(A6);
}
template <class T>
inline void CLR(priority_queue<T, vector<T>, less<T> > &Q) {
while (!Q.empty()) Q.pop();
}
template <class T>
inline void CLR(priority_queue<T, vector<T>, greater<T> > &Q) {
while (!Q.empty()) Q.pop();
}
template <class T>
inline void CLR(T &A) {
A.clear();
}
template <class T0, class T1>
inline void CLR(T0 &A0, T1 &A1) {
CLR(A0), CLR(A1);
}
template <class T0, class T1, class T2>
inline void CLR(T0 &A0, T1 &A1, T2 &A2) {
CLR(A0), CLR(A1), CLR(A2);
}
template <class T0, class T1, class T2, class T3>
inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3) {
CLR(A0), CLR(A1), CLR(A2), CLR(A3);
}
template <class T0, class T1, class T2, class T3, class T4>
inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4) {
CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4);
}
template <class T0, class T1, class T2, class T3, class T4, class T5>
inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5) {
CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4), CLR(A5);
}
template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6) {
CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4), CLR(A5), CLR(A6);
}
template <class T>
inline void CLR(T &A, int n) {
for (int i = 0; i < int(n); ++i) CLR(A[i]);
}
template <class T>
inline void FLC(T &A, int x) {
memset(A, x, sizeof(A));
}
template <class T0, class T1>
inline void FLC(T0 &A0, T1 &A1, int x) {
FLC(A0, x), FLC(A1, x);
}
template <class T0, class T1, class T2>
inline void FLC(T0 &A0, T1 &A1, T2 &A2) {
FLC(A0), FLC(A1), FLC(A2);
}
template <class T0, class T1, class T2, class T3>
inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3) {
FLC(A0), FLC(A1), FLC(A2), FLC(A3);
}
template <class T0, class T1, class T2, class T3, class T4>
inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4) {
FLC(A0), FLC(A1), FLC(A2), FLC(A3), FLC(A4);
}
template <class T0, class T1, class T2, class T3, class T4, class T5>
inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5) {
FLC(A0), FLC(A1), FLC(A2), FLC(A3), FLC(A4), FLC(A5);
}
template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6) {
FLC(A0), FLC(A1), FLC(A2), FLC(A3), FLC(A4), FLC(A5), FLC(A6);
}
template <class T>
inline void SRT(T &A) {
sort(A.begin(), A.end());
}
template <class T, class C>
inline void SRT(T &A, C B) {
sort(A.begin(), A.end(), B);
}
const int MOD = 1000000007;
const int INF = 0x3f3f3f3f;
const long long INF_64 = 0x3f3f3f3f3f3f3f3fLL;
const double EPS = 1e-8;
const double OO = 1e15;
const double PI = acos(-1.0);
template <class T>
inline void checkMin(T &a, const T b) {
if (b < a) a = b;
}
template <class T>
inline void checkMax(T &a, const T b) {
if (b > a) a = b;
}
template <class T, class C>
inline void checkMin(T &a, const T b, C c) {
if (c(b, a)) a = b;
}
template <class T, class C>
inline void checkMax(T &a, const T b, C c) {
if (c(a, b)) a = b;
}
template <class T>
inline T min(T a, T b, T c) {
return min(min(a, b), c);
}
template <class T>
inline T max(T a, T b, T c) {
return max(max(a, b), c);
}
template <class T>
inline T min(T a, T b, T c, T d) {
return min(min(a, b), min(c, d));
}
template <class T>
inline T max(T a, T b, T c, T d) {
return max(min(a, b), max(c, d));
}
template <class T, class C>
inline T min_cp(T a, T b, C cp) {
return min(a, b, cp);
}
template <class T, class C>
inline T min_cp(T a, T b, T c, C cp) {
return min_cp(min_cp(a, b, cp), c, cp);
}
template <class T, class C>
inline T min_cp(T a, T b, T c, T d, C cp) {
return min_cp(min_cp(a, b, cp), min_cp(c, d, cp), cp);
}
template <class T, class C>
inline T max_cp(T a, T b, C cp) {
return max(a, b, cp);
}
template <class T, class C>
inline T max_cp(T a, T b, T c, C cp) {
return max_cp(max_cp(a, b, cp), c, cp);
}
template <class T, class C>
inline T max_cp(T a, T b, T c, T d, C cp) {
return max_cp(max_cp(a, b, cp), max_cp(c, d, cp), cp);
}
template <class T>
inline T sqr(T a) {
return a * a;
}
template <class T>
inline T cub(T a) {
return a * a * a;
}
int Ceil(int x, int y) { return (x - 1) / y + 1; }
inline bool _1(int x, int i) { return x & 1 << i; }
inline bool _1(long long x, int i) { return x & 1LL << i; }
inline long long _1(int i) { return 1LL << i; }
inline long long _U(int i) { return _1(i) - 1; };
template <class T>
inline T low_bit(T x) {
return x & -x;
}
template <class T>
inline T high_bit(T x) {
T p = low_bit(x);
while (p != x) x -= p, p = low_bit(x);
return p;
}
template <class T>
inline T cover_bit(T x) {
T p = 1;
while (p < x) p <<= 1;
return p;
}
inline int count_bits(int x) {
x = (x & 0x55555555) + ((x & 0xaaaaaaaa) >> 1);
x = (x & 0x33333333) + ((x & 0xcccccccc) >> 2);
x = (x & 0x0f0f0f0f) + ((x & 0xf0f0f0f0) >> 4);
x = (x & 0x00ff00ff) + ((x & 0xff00ff00) >> 8);
x = (x & 0x0000ffff) + ((x & 0xffff0000) >> 16);
return x;
}
inline int count_bits(long long x) {
x = (x & 0x5555555555555555LL) + ((x & 0xaaaaaaaaaaaaaaaaLL) >> 1);
x = (x & 0x3333333333333333LL) + ((x & 0xccccccccccccccccLL) >> 2);
x = (x & 0x0f0f0f0f0f0f0f0fLL) + ((x & 0xf0f0f0f0f0f0f0f0LL) >> 4);
x = (x & 0x00ff00ff00ff00ffLL) + ((x & 0xff00ff00ff00ff00LL) >> 8);
x = (x & 0x0000ffff0000ffffLL) + ((x & 0xffff0000ffff0000LL) >> 16);
x = (x & 0x00000000ffffffffLL) + ((x & 0xffffffff00000000LL) >> 32);
return x;
}
int reverse_bits(int x) {
x = ((x >> 1) & 0x55555555) | ((x << 1) & 0xaaaaaaaa);
x = ((x >> 2) & 0x33333333) | ((x << 2) & 0xcccccccc);
x = ((x >> 4) & 0x0f0f0f0f) | ((x << 4) & 0xf0f0f0f0);
x = ((x >> 8) & 0x00ff00ff) | ((x << 8) & 0xff00ff00);
x = ((x >> 16) & 0x0000ffff) | ((x << 16) & 0xffff0000);
return x;
}
long long reverse_bits(long long x) {
x = ((x >> 1) & 0x5555555555555555LL) | ((x << 1) & 0xaaaaaaaaaaaaaaaaLL);
x = ((x >> 2) & 0x3333333333333333LL) | ((x << 2) & 0xccccccccccccccccLL);
x = ((x >> 4) & 0x0f0f0f0f0f0f0f0fLL) | ((x << 4) & 0xf0f0f0f0f0f0f0f0LL);
x = ((x >> 8) & 0x00ff00ff00ff00ffLL) | ((x << 8) & 0xff00ff00ff00ff00LL);
x = ((x >> 16) & 0x0000ffff0000ffffLL) | ((x << 16) & 0xffff0000ffff0000LL);
x = ((x >> 32) & 0x00000000ffffffffLL) | ((x << 32) & 0xffffffff00000000LL);
return x;
}
using namespace std;
class bignum {
friend istream &operator>>(istream &, bignum &);
friend ostream &operator<<(ostream &, const bignum &);
friend bignum operator+(const bignum &, const bignum &);
friend bignum operator-(const bignum &, const bignum &);
friend bignum operator*(const bignum &, const bignum &);
friend bignum operator/(const bignum &, const bignum &);
friend bignum operator%(const bignum &, const bignum &);
friend bignum operator+(const bignum &, const int &);
friend bignum operator-(const bignum &, const int &);
friend bignum operator*(const bignum &, const int &);
friend bignum operator/(const bignum &, const int &);
friend bignum operator%(const bignum &, const int &);
friend bool operator==(const bignum &, const bignum &);
friend bool operator!=(const bignum &, const bignum &);
friend bool operator<(const bignum &, const bignum &);
friend bool operator>(const bignum &, const bignum &);
friend bool operator<=(const bignum &, const bignum &);
friend bool operator>=(const bignum &, const bignum &);
friend bool operator==(const bignum &, const int &);
friend bool operator!=(const bignum &, const int &);
friend bool operator<(const bignum &, const int &);
friend bool operator>(const bignum &, const int &);
friend bool operator<=(const bignum &, const int &);
friend bool operator>=(const bignum &, const int &);
friend int do_comp(const bignum &, const int &);
friend int do_comp(const bignum &, const bignum &);
friend void divide(const bignum &, const bignum &, bignum &, bignum &);
friend bignum pow(bignum, int);
public:
inline bignum(){};
inline bignum(int s) {
while (s != 0) {
data.push_back(s % 100000000);
s /= 100000000;
}
if (data.empty()) data.push_back(0);
}
inline bignum(long long s) {
while (s != 0) {
data.push_back(int(s % 100000000));
s /= 100000000;
}
if (data.empty()) data.push_back(0);
}
inline bignum(string s) {
int t, i;
data.clear();
for (i = int(s.size()) - 8; i > 0; i -= 8) {
istringstream(s.substr(i, 8)) >> t;
data.push_back(t);
}
istringstream(s.substr(0, i + 8)) >> t;
data.push_back(t);
}
void operator=(const int);
void operator=(const string);
void operator=(const bignum);
bignum &operator+=(const bignum &);
bignum &operator-=(const bignum &);
bignum &operator*=(const bignum &);
bignum &operator/=(const bignum &);
bignum &operator%=(const bignum &);
bignum &operator+=(const int &);
bignum &operator-=(const int &);
bignum &operator*=(const int &);
bignum &operator/=(const int &);
bignum &operator%=(const int &);
bignum &operator%=(const long long &);
bool undefined();
int do_try(const int &);
int do_try(const bignum &);
void do_trim();
list<int> data;
void add(const int a) {
list<int>::iterator it = data.end();
it--;
if ((*it) < 10)
(*it) = a;
else if ((*it) < 100)
(*it) = (*it) % 10 + 10 * a;
else if ((*it) < 1000)
(*it) = (*it) % 100 + 100 * a;
else if ((*it) < 10000)
(*it) = (*it) % 1000 + 1000 * a;
else if ((*it) < 100000)
(*it) = (*it) % 10000 + 10000 * a;
else if ((*it) < 1000000)
(*it) = (*it) % 100000 + 100000 * a;
else if ((*it) < 10000000)
(*it) = (*it) % 1000000 + 1000000 * a;
else if ((*it) < 100000000)
(*it) = (*it) % 10000000 + 10000000 * a;
}
void clear() { data.clear(); }
long long t() {
if (data.size() == 1)
return *data.begin();
else {
list<int>::iterator it = data.begin(), jt = data.begin();
++it;
return (long long)(*it) * 100000000 + (*jt);
}
}
int size() {
list<int>::iterator it;
int res = 0;
for (it = data.begin(); it != data.end(); it++) res += 8;
it--;
if (*it >= 10000) {
if ((*it) >= 1000000) {
if (*it >= 10000000)
;
else
res--;
} else {
if ((*it) >= 100000)
res -= 2;
else
res -= 3;
}
} else if ((*it) >= 100) {
if (*it >= 1000)
res -= 4;
else
res -= 5;
} else {
if ((*it) >= 10)
res -= 6;
else
res -= 7;
}
return res;
}
void do_reserve(int a) {
if (a <= 0) return;
list<int>::iterator it;
for (it = data.begin(); it != data.end() && a > 0; it++) a -= 8;
if (it == data.end() && a >= 0) return;
a += 8, it--;
int f = 1;
for (int i = 0; i < a; i++) f *= 10;
(*it) %= f;
data.erase(++it, data.end());
do_trim();
}
void output() {
list<int>::const_reverse_iterator i = data.rbegin();
printf("%d", *i);
for (i++; i != data.rend(); i++) printf("%08d", *i);
}
};
inline void bignum::operator=(const bignum a) {
data.clear();
for (list<int>::const_iterator i = a.data.begin(); i != a.data.end(); i++) {
data.push_back(*i);
}
}
inline void bignum::operator=(const string a) { (*this) = bignum(a); }
inline void bignum::operator=(const int a) { (*this) = bignum(a); }
inline istream &operator>>(istream &input, bignum &a) {
string s;
int t, i;
input >> s;
a.data.clear();
for (i = int(s.size()) - 8; i > 0; i -= 8) {
istringstream(s.substr(i, 8)) >> t;
a.data.push_back(t);
}
istringstream(s.substr(0, i + 8)) >> t;
a.data.push_back(t);
return input;
}
inline ostream &operator<<(ostream &output, const bignum &a) {
list<int>::const_reverse_iterator i = a.data.rbegin();
output << *i;
for (i++; i != a.data.rend(); i++) {
if (*i >= 10000) {
if (*i >= 1000000) {
if (*i >= 10000000)
cout << *i;
else
cout << 0 << *i;
} else {
if (*i >= 100000)
cout << "00" << *i;
else
cout << "000" << *i;
}
} else {
if (*i >= 100) {
if (*i >= 1000)
cout << "0000" << *i;
else
cout << "00000" << *i;
} else {
if (*i >= 10)
cout << "000000" << *i;
else
cout << "0000000" << *i;
}
}
}
return output;
}
inline bool bignum::undefined() { return data.empty(); }
inline int do_comp(const bignum &a, const bignum &b) {
if (a.data.size() < b.data.size()) return -1;
if (a.data.size() > b.data.size()) return 1;
list<int>::const_reverse_iterator i;
list<int>::const_reverse_iterator j;
for (i = a.data.rbegin(), j = b.data.rbegin(); j != b.data.rend(); i++, j++) {
if (*i < *j) return -1;
if (*i > *j) return 1;
}
return 0;
}
inline int do_comp(const bignum &a, const int &b) {
return do_comp(a, bignum(b));
}
inline bool operator==(const bignum &a, const bignum &b) {
return do_comp(a, b) == 0;
}
inline bool operator!=(const bignum &a, const bignum &b) {
return do_comp(a, b) != 0;
}
inline bool operator<(const bignum &a, const bignum &b) {
return do_comp(a, b) == -1;
}
inline bool operator>(const bignum &a, const bignum &b) {
return do_comp(a, b) == 1;
}
inline bool operator<=(const bignum &a, const bignum &b) {
return do_comp(a, b) != 1;
}
inline bool operator>=(const bignum &a, const bignum &b) {
return do_comp(a, b) != -1;
}
inline bool operator==(const bignum &a, const int &b) {
return do_comp(a, b) == 0;
}
inline bool operator!=(const bignum &a, const int &b) {
return do_comp(a, b) != 0;
}
inline bool operator<(const bignum &a, const int &b) {
return do_comp(a, b) == -1;
}
inline bool operator>(const bignum &a, const int &b) {
return do_comp(a, b) == 1;
}
inline bool operator<=(const bignum &a, const int &b) {
return do_comp(a, b) != 1;
}
inline bool operator>=(const bignum &a, const int &b) {
return do_comp(a, b) != -1;
}
inline void bignum::do_trim() {
while (data.size() > 1 && data.back() == 0) data.pop_back();
}
inline bignum &bignum::operator+=(const bignum &a) {
list<int>::iterator i;
list<int>::const_iterator j;
int t = 0;
for (i = data.begin(), j = a.data.begin();
i != data.end() && j != a.data.end(); i++, j++) {
*i += *j + t;
t = *i / 100000000;
*i %= 100000000;
}
while (i != data.end()) {
*i += t;
t = *i / 100000000;
*i %= 100000000;
i++;
}
while (j != a.data.end()) {
data.push_back(t + *j);
t = data.back() / 100000000;
data.back() %= 100000000;
j++;
}
if (t != 0) data.push_back(t);
return *this;
}
inline bignum &bignum::operator-=(const bignum &a) {
list<int>::iterator i;
list<int>::const_iterator j;
int t = 0;
for (i = data.begin(), j = a.data.begin(); j != a.data.end(); i++, j++) {
*i -= t + *j;
if (*i >= 0)
t = 0;
else
*i += 100000000, t = 1;
}
while (i != data.end()) {
*i -= t;
if (*i >= 0)
t = 0;
else
*i += 100000000, t = 1;
i++;
}
(*this).do_trim();
return *this;
}
inline bignum &bignum::operator+=(const int &a) { return (*this) += bignum(a); }
inline bignum &bignum::operator-=(const int &a) { return (*this) -= bignum(a); }
inline bignum operator+(const bignum &a, const bignum &b) {
list<int>::const_iterator i, j;
bignum c;
int t = 0;
for (i = a.data.begin(), j = b.data.begin();
i != a.data.end() && j != b.data.end(); i++, j++) {
c.data.push_back(t + *i + *j);
t = c.data.back() / 100000000;
c.data.back() %= 100000000;
}
while (i != a.data.end()) {
c.data.push_back(t + *i);
t = c.data.back() / 100000000;
c.data.back() %= 100000000;
i++;
}
while (j != b.data.end()) {
c.data.push_back(t + *j);
t = c.data.back() / 100000000;
c.data.back() %= 100000000;
j++;
}
if (t != 0) c.data.push_back(t);
return c;
}
inline bignum operator-(const bignum &a, const bignum &b) {
list<int>::const_iterator i, j;
bignum c;
int t = 0;
for (i = a.data.begin(), j = b.data.begin(); j != b.data.end(); i++, j++) {
t = *i - t;
if (t >= *j)
c.data.push_back(t - *j), t = 0;
else
c.data.push_back(t + 100000000 - *j), t = 1;
}
while (i != a.data.end()) {
t = *i - t;
if (t >= 0)
c.data.push_back(t), t = 0;
else
c.data.push_back(t + 100000000), t = 1;
i++;
}
c.do_trim();
return c;
}
inline bignum operator*(const bignum &a, const bignum &b) {
list<int>::const_iterator i, j;
list<int>::iterator k, kk;
bignum c;
long long t = 0;
for (int i = 0; i < a.data.size() + b.data.size(); i++) c.data.push_back(0);
for (i = a.data.begin(), k = c.data.begin(); i != a.data.end(); i++, k++) {
for (j = b.data.begin(), kk = k; j != b.data.end(); j++, kk++) {
t += (long long)(*i) * (*j) + (*kk);
*kk = int(t % 100000000);
t /= 100000000;
}
*kk += t;
t = 0;
}
c.do_trim();
return c;
}
inline int bignum::do_try(const bignum &a) {
int l = 1, r = 99999999, m, t;
while (l + 2 < r) {
m = (l + r) / 2;
t = do_comp(*this, a * bignum(m));
if (t == 0) return m;
if (t < 0)
r = m - 1;
else
l = m;
}
while (do_comp(*this, a * bignum(r)) < 0) r--;
return r;
}
inline void divide(const bignum &a, const bignum &b, bignum &d, bignum &r) {
list<int>::const_reverse_iterator i = a.data.rbegin();
int t;
d = bignum(0);
r = bignum(0);
do {
while (r < b && i != a.data.rend()) {
d.data.push_front(0);
r.data.push_front(*i);
r.do_trim();
i++;
}
if (r >= b) {
t = r.do_try(b);
d.data.front() = t;
r -= (b * bignum(t));
}
} while (i != a.data.rend());
d.do_trim();
}
inline bignum operator/(const bignum &a, const bignum &b) {
bignum d, r;
divide(a, b, d, r);
return d;
}
inline bignum operator%(const bignum &a, const bignum &b) {
bignum d, r;
divide(a, b, d, r);
return r;
}
inline bignum operator+(const bignum &a, const int &b) { return a + bignum(b); }
inline bignum operator-(const bignum &a, const int &b) { return a - bignum(b); }
inline bignum operator*(const bignum &a, const int &b) { return a * bignum(b); }
inline bignum operator/(const bignum &a, const int &b) { return a / bignum(b); }
inline bignum &bignum::operator*=(const bignum &a) {
(*this) = (*this) * a;
return *this;
}
inline bignum &bignum::operator/=(const bignum &a) {
(*this) = (*this) / a;
return *this;
}
inline bignum &bignum::operator%=(const bignum &a) {
(*this) = (*this) % a;
return *this;
}
inline bignum &bignum::operator*=(const int &a) { return (*this) *= bignum(a); }
inline bignum &bignum::operator/=(const int &a) { return (*this) /= bignum(a); }
inline bignum &bignum::operator%=(const long long &b) {
return (*this) %= bignum(b);
}
inline bignum pow(bignum a, int b) {
bignum c(1);
while (b != 0) {
if (b & 1) c *= a;
a = a * a;
b >>= 1;
}
return c;
}
inline int rand32() {
return (bool(rand() & 1) << 30) | (rand() << 15) + rand();
}
inline int random32(int l, int r) { return rand32() % (r - l + 1) + l; }
inline int random(int l, int r) { return rand() % (r - l + 1) + l; }
int dice() { return rand() % 6; }
bool coin() { return rand() % 2; }
template <class T>
inline void RD(T &x) {
char c;
for (c = getchar(); c < '0'; c = getchar())
;
x = c - '0';
for (c = getchar(); c >= '0'; c = getchar()) x = x * 10 + c - '0';
}
template <class T>
inline void OT(const T &x) {
printf("%d\n", x);
}
const int maxL = 3 << 20;
const int maxn = 50000 + 5;
char s[maxL];
int k;
int n, L[maxn], R[maxn];
char r[maxL];
class Segment {
public:
int L;
char *s;
};
int n_segs;
Segment segs[maxn << 2];
int split(int pos) {
for (int i = 0; i < n_segs; i++)
if (pos == 0) {
n_segs++;
for (int k = n_segs - 1; k > i; k--) segs[k] = segs[k - 1];
return i;
} else if (segs[i].L <= pos)
pos -= segs[i].L;
else {
n_segs += 2;
for (int k = n_segs - 1; k > i + 1; k--) segs[k] = segs[k - 2];
segs[i + 2].L = segs[i].L - pos;
segs[i + 2].s = segs[i].s + pos;
segs[i].L = pos;
return i + 1;
}
return n_segs++;
}
void getr(int H, int T) {
int L = 0;
for (int i = 0; T >= 0 && i < n_segs; i++) {
for (int k = max(0, H); k < segs[i].L && k <= T; k++) r[L++] = segs[i].s[k];
int D = segs[i].L;
H -= D;
T -= D;
}
}
void construct(int d, int length) {
if (d < 0) {
Segment key;
key.L = length;
key.s = s;
segs[n_segs++] = key;
return;
}
if (R[d] >= length) {
construct(d - 1, length);
return;
}
int C = R[d] - L[d] + 1;
if (R[d] + C >= length) {
construct(d - 1, R[d]);
Segment key;
key.L = length - R[d];
key.s = new char[key.L];
int C_2 = C / 2;
int D = (key.L >= C_2) ? C : (key.L * 2);
getr(L[d], L[d] + D - 1);
for (int i = 0; i < key.L; i++)
if (i < C_2)
key.s[i] = r[i + i + 1];
else
key.s[i] = r[(i - C_2) << 1];
segs[n_segs++] = key;
} else {
construct(d - 1, length - C);
int pos = split(R[d] + 1);
Segment key;
key.L = C;
key.s = new char[C];
int C_2 = C / 2;
getr(L[d], R[d]);
for (int i = 0; i < C; i++)
if (i < C_2)
key.s[i] = r[i + i + 1];
else
key.s[i] = r[(i - C_2) << 1];
segs[pos] = key;
}
}
int main() {
scanf("%s%d", s, &k);
++k;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d%d", &L[i], &R[i]);
n_segs = 1;
segs[0].L = 1;
segs[0].s = new char[1];
segs[0].s[0] = ' ';
construct(n - 1, k);
getr(0, k);
r[k] = 0;
printf("%s\n", r + 1);
return 0;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
Valery is a PE teacher at a school in Berland. Soon the students are going to take a test in long jumps, and Valery has lost his favorite ruler!
However, there is no reason for disappointment, as Valery has found another ruler, its length is l centimeters. The ruler already has n marks, with which he can make measurements. We assume that the marks are numbered from 1 to n in the order they appear from the beginning of the ruler to its end. The first point coincides with the beginning of the ruler and represents the origin. The last mark coincides with the end of the ruler, at distance l from the origin. This ruler can be repesented by an increasing sequence a1, a2, ..., an, where ai denotes the distance of the i-th mark from the origin (a1 = 0, an = l).
Valery believes that with a ruler he can measure the distance of d centimeters, if there is a pair of integers i and j (1 ≤ i ≤ j ≤ n), such that the distance between the i-th and the j-th mark is exactly equal to d (in other words, aj - ai = d).
Under the rules, the girls should be able to jump at least x centimeters, and the boys should be able to jump at least y (x < y) centimeters. To test the children's abilities, Valery needs a ruler to measure each of the distances x and y.
Your task is to determine what is the minimum number of additional marks you need to add on the ruler so that they can be used to measure the distances x and y. Valery can add the marks at any integer non-negative distance from the origin not exceeding the length of the ruler.
Input
The first line contains four positive space-separated integers n, l, x, y (2 ≤ n ≤ 105, 2 ≤ l ≤ 109, 1 ≤ x < y ≤ l) — the number of marks, the length of the ruler and the jump norms for girls and boys, correspondingly.
The second line contains a sequence of n integers a1, a2, ..., an (0 = a1 < a2 < ... < an = l), where ai shows the distance from the i-th mark to the origin.
Output
In the first line print a single non-negative integer v — the minimum number of marks that you need to add on the ruler.
In the second line print v space-separated integers p1, p2, ..., pv (0 ≤ pi ≤ l). Number pi means that the i-th mark should be at the distance of pi centimeters from the origin. Print the marks in any order. If there are multiple solutions, print any of them.
Examples
Input
3 250 185 230
0 185 250
Output
1
230
Input
4 250 185 230
0 20 185 250
Output
0
Input
2 300 185 230
0 300
Output
2
185 230
Note
In the first sample it is impossible to initially measure the distance of 230 centimeters. For that it is enough to add a 20 centimeter mark or a 230 centimeter mark.
In the second sample you already can use the ruler to measure the distances of 185 and 230 centimeters, so you don't have to add new marks.
In the third sample the ruler only contains the initial and the final marks. We will need to add two marks to be able to test the children's skills.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, l, x, y;
int a[N];
map<int, bool> exist;
vector<int> coolx;
vector<int> cooly;
bool check(int d) {
int low, high, mid;
low = 1;
high = n;
while (low <= high) {
mid = (low + high) / 2;
if (d - a[mid] == x) return true;
if (d - a[mid] < x)
high = mid - 1;
else
low = mid + 1;
}
low = 1;
high = n;
while (low <= high) {
mid = (low + high) / 2;
if (a[mid] - d == x) return true;
if (a[mid] - d < x)
low = mid + 1;
else
high = mid - 1;
}
return false;
}
int main() {
int i;
cin >> n >> l >> x >> y;
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i <= n; i++) {
if (a[i] >= x)
if (exist[a[i] - x]) coolx.push_back(i);
exist[a[i]] = true;
}
exist.clear();
for (i = 1; i <= n; i++) {
if (a[i] >= y)
if (exist[a[i] - y]) cooly.push_back(i);
exist[a[i]] = true;
}
if (coolx.size() > 0 && cooly.size() > 0) {
cout << 0 << endl;
return 0;
}
if (coolx.size() > 0 && cooly.size() == 0) {
cout << 1 << endl;
for (i = 1; i <= n; i++) {
if (a[i] >= y) {
cout << a[i] - y << endl;
break;
}
}
return 0;
}
if (coolx.size() == 0 && cooly.size() > 0) {
cout << 1 << endl;
for (i = 1; i <= n; i++) {
if (a[i] >= x) {
cout << a[i] - x << endl;
break;
}
}
return 0;
}
int d;
for (i = 1; i <= n; i++) {
d = a[i] + y;
if (d <= l)
if (check(d)) {
cout << 1 << endl;
cout << d << endl;
return 0;
}
if (a[i] >= y) {
d = a[i] - y;
if (check(d)) {
cout << 1 << endl;
cout << d << endl;
return 0;
}
}
}
cout << 2 << endl;
cout << x << " " << y << endl;
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
In 2215 A.D., a war between two planets, ACM and ICPC, is being more and more intense.
ACM introduced new combat planes. These planes have a special system that is called Graze, and fighting power of a plane increases when it is close to energy bullets that ICPC combat planes shoot.
Both combat planes and energy bullets have a shape of a sphere with a radius of R. Precisely, fighting power of a plane is equivalent to the number of energy bullet where distance from the plane is less than or equals to 2R.
You, helper of captain of intelligence units, are asked to analyze a war situation. The information given to you is coordinates of AN combat planes and BN energy bullets. Additionally, you know following things:
* All combat planes and energy bullet has same z-coordinates. In other word, z-coordinate can be ignored.
* No two combat planes, no two energy bullets, and no pair of combat plane and energy bullet collide (i.e. have positive common volume) each other.
Your task is to write a program that outputs total fighting power of all combat planes.
Constraints
* Jude data includes at most 20 data sets.
* 1 ≤ AN, BN ≤ 100000
* 0 < R ≤ 10
* 0 ≤ (coordinate values) < 10000
Input
Input file consists of a number of data sets. One data set is given in following format:
AN BN R
XA1 YA1
XA2 YA2
:
XAAN YAAN
XB1 YB1
XB2 YB2
:
XBBN YBBN
AN, BN, R are integers that describe the number of combat planes, energy bullets, and their radius respectively.
Following AN lines indicate coordinates of the center of combat planes. Each line has two integers that describe x-coordinate and y-coordinate.
Following BN lines indicate coordinates of the center of energy bullets, in the same format as that of combat planes.
Input ends when AN = BN = 0. You should output nothing for this case.
Output
For each data set, output the total fighting power.
Example
Input
2 2 1
0 0
0 4
2 2
2 8
0 0 0
Output
2
### Response
```cpp
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <iostream>
#include <math.h>
#include <assert.h>
#include <vector>
#include <set>
using namespace std;
typedef long long ll;
static const double EPS = 1e-9;
static const double PI = acos(-1.0);
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define FOR(i, s, n) for (int i = (s); i < (int)(n); i++)
#define FOREQ(i, s, n) for (int i = (s); i <= (int)(n); i++)
#define FORIT(it, c) for (__typeof((c).begin())it = (c).begin(); it != (c).end(); it++)
#define MEMSET(v, h) memset((v), h, sizeof(v))
struct Point {
int x;
int y;
int type;
Point() {;}
Point(double x, double y, int type) : x(x), y(y), type(type) {;}
bool operator<(const Point &rhs) const {
if (fabs(y - rhs.y) > EPS) { return y < rhs.y; }
if (fabs(x - rhs.x) > EPS) { return x < rhs.x; }
return false;
}
};
struct Event {
int x;
Point p;
int in;
Event() {;}
Event(int x, Point p, int in) : x(x), p(p), in(in) {;}
bool operator<(const Event &rhs) const {
if (x != rhs.x) { return x < rhs.x; }
return in > rhs.in;
}
};
inline int square(int x) { return x * x; }
inline int dist2(const Point &a, const Point &b) {
return square(a.x - b.x) + square(a.y - b.y);
}
int an, bn, n;
int r;
Event event[500000];
int PlaneSweep() {
int ans = 0;
set<Point> open[2];
REP(iter, n) {
Event &e = event[iter];
Point &p = e.p;
if (e.in) {
set<Point>::iterator lower = open[p.type ^ 1].lower_bound(Point(0, p.y - 4.0 * r - 1, 0));
set<Point>::iterator upper = open[p.type ^ 1].upper_bound(Point(0, p.y + 4.0 * r + 1, 0));
for (set<Point>::iterator it = lower; it != upper; it++) {
if (dist2(*it, p) <= 16.0 * r * r) { ans++; }
}
open[p.type].insert(p);
} else {
open[p.type].erase(open[p.type].find(p));
}
}
return ans;
}
int main() {
while (scanf("%d %d %d", &an, &bn, &r), an|bn) {
n = (an + bn) * 2;
REP(i, an) {
int x, y;
scanf("%d %d", &x, &y);
event[2 * i + 0] = Event(x - 2 * r, Point(x, y, 0), 1);
event[2 * i + 1] = Event(x + 2 * r, Point(x, y, 0), 0);
}
REP(i, bn) {
int x, y;
scanf("%d %d", &x, &y);
event[2 * an + 2 * i + 0] = Event(x - 2 * r, Point(x, y, 1), 1);
event[2 * an + 2 * i + 1] = Event(x + 2 * r, Point(x, y, 1), 0);
}
sort(event, event + n);
int ans = PlaneSweep();
printf("%d\n", ans);
}
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
Unlucky year in Berland is such a year that its number n can be represented as n = xa + yb, where a and b are non-negative integer numbers.
For example, if x = 2 and y = 3 then the years 4 and 17 are unlucky (4 = 20 + 31, 17 = 23 + 32 = 24 + 30) and year 18 isn't unlucky as there is no such representation for it.
Such interval of years that there are no unlucky years in it is called The Golden Age.
You should write a program which will find maximum length of The Golden Age which starts no earlier than the year l and ends no later than the year r. If all years in the interval [l, r] are unlucky then the answer is 0.
Input
The first line contains four integer numbers x, y, l and r (2 ≤ x, y ≤ 1018, 1 ≤ l ≤ r ≤ 1018).
Output
Print the maximum length of The Golden Age within the interval [l, r].
If all years in the interval [l, r] are unlucky then print 0.
Examples
Input
2 3 1 10
Output
1
Input
3 5 10 22
Output
8
Input
2 3 3 5
Output
0
Note
In the first example the unlucky years are 2, 3, 4, 5, 7, 9 and 10. So maximum length of The Golden Age is achived in the intervals [1, 1], [6, 6] and [8, 8].
In the second example the longest Golden Age is the interval [15, 22].
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
const int maxn = 3e5 + 5;
const int INF = 0x7fffffff;
const int inf = 0x3f3f3f3f;
const double eps = 1e-8;
vector<long long> a, b;
set<long long> s;
int main() {
long long x, y, l, r;
scanf("%I64d%I64d%I64d%I64d", &x, &y, &l, &r);
long long k = 1;
for (int i = 1; i <= 64; i++) {
a.push_back(k);
if (r / k < x) break;
k *= x;
}
k = 1;
for (int i = 1; i <= 64; i++) {
b.push_back(k);
if (r / k < y) break;
k *= y;
}
for (int i = 0; i < a.size(); i++) {
for (int j = 0; j < b.size(); j++) {
if (a[i] + b[j] >= l && a[i] + b[j] <= r) {
s.insert(a[i] + b[j]);
}
}
}
long long res = 0;
k = l - 1;
for (set<long long>::iterator ite = s.begin(); ite != s.end(); ite++) {
res = max(res, *ite - k - 1);
k = *ite;
}
res = max(res, r - k);
cout << res << endl;
return 0;
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
This is an interactive problem!
Ehab plays a game with Laggy. Ehab has 2 hidden integers (a,b). Laggy can ask a pair of integers (c,d) and Ehab will reply with:
* 1 if a ⊕ c>b ⊕ d.
* 0 if a ⊕ c=b ⊕ d.
* -1 if a ⊕ c<b ⊕ d.
Operation a ⊕ b is the [bitwise-xor operation](https://en.wikipedia.org/wiki/Bitwise_operation#XOR) of two numbers a and b.
Laggy should guess (a,b) with at most 62 questions. You'll play this game. You're Laggy and the interactor is Ehab.
It's guaranteed that 0 ≤ a,b<2^{30}.
Input
See the interaction section.
Output
To print the answer, print "! a b" (without quotes). Don't forget to flush the output after printing the answer.
Interaction
To ask a question, print "? c d" (without quotes). Both c and d must be non-negative integers less than 2^{30}. Don't forget to flush the output after printing any question.
After each question, you should read the answer as mentioned in the legend. If the interactor replies with -2, that means you asked more than 62 queries and your program should terminate.
To flush the output, you can use:-
* fflush(stdout) in C++.
* System.out.flush() in Java.
* stdout.flush() in Python.
* flush(output) in Pascal.
* See the documentation for other languages.
Hacking:
To hack someone, print the 2 space-separated integers a and b (0 ≤ a,b<2^{30}).
Example
Input
1
-1
0
Output
? 2 1
? 1 2
? 2 0
! 3 1
Note
In the sample:
The hidden numbers are a=3 and b=1.
In the first query: 3 ⊕ 2 = 1 and 1 ⊕ 1 = 0, so the answer is 1.
In the second query: 3 ⊕ 1 = 2 and 1 ⊕ 2 = 3, so the answer is -1.
In the third query: 3 ⊕ 2 = 1 and 1 ⊕ 0 = 1, so the answer is 0.
Then, we printed the answer.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int x;
cout << "? 0 0\n";
cin >> x;
int a = 0, b = 0;
int c = 0, d = 0;
if (x == 0) {
for (int i = 29; i >= 0; --i) {
cout << "? " << (a ^ (1 << i)) << ' ' << b << "\n";
cin >> x;
if (x == -1) {
a ^= (1 << i);
b ^= (1 << i);
}
}
cout << "! " << a << ' ' << b;
} else {
int y;
int q = x;
for (int i = 29; i >= 0; --i) {
if (q == 1) {
cout << "? " << a << ' ' << (b ^ (1 << i)) << "\n";
cin >> x;
cout << "? " << (a ^ (1 << i)) << ' ' << (b ^ (1 << i)) << "\n";
cin >> y;
if (x == -1) {
if (y == -1) {
q = -1;
a ^= (1 << i);
}
} else if (x == 1) {
if (y == -1) {
a ^= (1 << i);
} else if (y == 1) {
a ^= (1 << i);
b ^= (1 << i);
}
} else {
a ^= (1 << i);
q = 0;
}
} else if (q == 0) {
cout << "? " << a << ' ' << (b ^ (1 << i)) << "\n";
cin >> x;
if (x == 1) {
a ^= (1 << i);
b ^= (1 << i);
}
} else {
cout << "? " << (a ^ (1 << i)) << ' ' << b << "\n";
cin >> x;
cout << "? " << (a ^ (1 << i)) << ' ' << (b ^ (1 << i)) << "\n";
cin >> y;
if (x == 1) {
if (y == 1) {
q = 1;
b ^= (1 << i);
}
} else if (x == -1) {
if (y == 1) {
b ^= (1 << i);
} else if (y == -1) {
a ^= (1 << i);
b ^= (1 << i);
}
} else {
b ^= (1 << i);
q = 0;
}
}
}
cout << "! " << a << ' ' << b;
}
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
After all the events in Orlando we all know, Sasha and Roma decided to find out who is still the team's biggest loser. Thankfully, Masha found somewhere a revolver with a rotating cylinder of n bullet slots able to contain exactly k bullets, now the boys have a chance to resolve the problem once and for all.
Sasha selects any k out of n slots he wishes and puts bullets there. Roma spins the cylinder so that every of n possible cylinder's shifts is equiprobable. Then the game starts, the players take turns, Sasha starts: he puts the gun to his head and shoots. If there was no bullet in front of the trigger, the cylinder shifts by one position and the weapon is given to Roma for make the same move. The game continues until someone is shot, the survivor is the winner.
Sasha does not want to lose, so he must choose slots for bullets in such a way as to minimize the probability of its own loss. Of all the possible variant he wants to select the lexicographically minimal one, where an empty slot is lexicographically less than a charged one.
More formally, the cylinder of n bullet slots able to contain k bullets can be represented as a string of n characters. Exactly k of them are "X" (charged slots) and the others are "." (uncharged slots).
Let us describe the process of a shot. Suppose that the trigger is in front of the first character of the string (the first slot). If a shot doesn't kill anyone and the cylinder shifts, then the string shifts left. So the first character becomes the last one, the second character becomes the first one, and so on. But the trigger doesn't move. It will be in front of the first character of the resulting string.
Among all the strings that give the minimal probability of loss, Sasha choose the lexicographically minimal one. According to this very string, he charges the gun. You have to help Sasha to charge the gun. For that, each xi query must be answered: is there a bullet in the positions xi?
Input
The first line contains three integers n, k and p (1 ≤ n ≤ 1018, 0 ≤ k ≤ n, 1 ≤ p ≤ 1000) — the number of slots in the cylinder, the number of bullets and the number of queries. Then follow p lines; they are the queries. Each line contains one integer xi (1 ≤ xi ≤ n) the number of slot to describe.
Please do not use the %lld specificator to read or write 64-bit numbers in С++. It is preferred to use cin, cout streams or the %I64d specificator.
Output
For each query print "." if the slot should be empty and "X" if the slot should be charged.
Examples
Input
3 1 3
1
2
3
Output
..X
Input
6 3 6
1
2
3
4
5
6
Output
.X.X.X
Input
5 2 5
1
2
3
4
5
Output
...XX
Note
The lexicographical comparison of is performed by the < operator in modern programming languages. The a string is lexicographically less that the b string, if there exists such i (1 ≤ i ≤ n), that ai < bi, and for any j (1 ≤ j < i) aj = bj.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k, p, j;
cin >> n >> k >> p;
string s;
for (int i = 0; i < p; ++i) {
cin >> j;
bool charged = false;
if (n % 2 == 1) {
if (n - j == 0) {
if (k > 0) {
charged = true;
}
} else if ((n - j) % 2 == 1) {
if (k > (n - (j - 1)) / 2) {
charged = true;
}
} else {
if (k - (n + 1) / 2 > (n - j) / 2 - 1) {
charged = true;
}
}
} else {
if ((n - j) % 2 == 0) {
if (k > (n - j) / 2) {
charged = true;
}
} else {
if (k - n / 2 > (n - (j + 1)) / 2) {
charged = true;
}
}
}
s += (charged ? 'X' : '.');
}
cout << s << endl;
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
To your surprise, Jamie is the final boss! Ehehehe.
Jamie has given you a tree with n vertices, numbered from 1 to n. Initially, the root of the tree is the vertex with number 1. Also, each vertex has a value on it.
Jamie also gives you three types of queries on the tree:
1 v — Change the tree's root to vertex with number v.
2 u v x — For each vertex in the subtree of smallest size that contains u and v, add x to its value.
3 v — Find sum of values of vertices in the subtree of vertex with number v.
A subtree of vertex v is a set of vertices such that v lies on shortest path from this vertex to root of the tree. Pay attention that subtree of a vertex can change after changing the tree's root.
Show your strength in programming to Jamie by performing the queries accurately!
Input
The first line of input contains two space-separated integers n and q (1 ≤ n ≤ 105, 1 ≤ q ≤ 105) — the number of vertices in the tree and the number of queries to process respectively.
The second line contains n space-separated integers a1, a2, ..., an ( - 108 ≤ ai ≤ 108) — initial values of the vertices.
Next n - 1 lines contains two space-separated integers ui, vi (1 ≤ ui, vi ≤ n) describing edge between vertices ui and vi in the tree.
The following q lines describe the queries.
Each query has one of following formats depending on its type:
1 v (1 ≤ v ≤ n) for queries of the first type.
2 u v x (1 ≤ u, v ≤ n, - 108 ≤ x ≤ 108) for queries of the second type.
3 v (1 ≤ v ≤ n) for queries of the third type.
All numbers in queries' descriptions are integers.
The queries must be carried out in the given order. It is guaranteed that the tree is valid.
Output
For each query of the third type, output the required answer. It is guaranteed that at least one query of the third type is given by Jamie.
Examples
Input
6 7
1 4 2 8 5 7
1 2
3 1
4 3
4 5
3 6
3 1
2 4 6 3
3 4
1 6
2 2 4 -5
1 4
3 3
Output
27
19
5
Input
4 6
4 3 5 6
1 2
2 3
3 4
3 1
1 3
2 2 4 3
1 1
2 2 4 -3
3 1
Output
18
21
Note
The following picture shows how the tree varies after the queries in the first sample.
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
inline int rd() {
int a = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) a = a * 10 + (ch ^ 48), ch = getchar();
return a * f;
}
long long n, m, root = 1;
long long st[100009], rev[100009], top[100009], fa[100009], siz[100009],
son[100009], dep[100009], a[100009], ed[100009], timer;
long long val[100009 << 2], tag[100009 << 2];
vector<long long> g[100009];
void dfs1(long long u, long long ft) {
siz[u] = 1;
for (long long v : g[u]) {
if (v == ft) continue;
fa[v] = u, dep[v] = dep[u] + 1, dfs1(v, u), siz[u] += siz[v];
if (siz[v] > siz[son[u]]) son[u] = v;
}
}
void dfs2(long long u, long long tp) {
top[u] = tp, st[u] = ++timer, rev[timer] = u;
if (son[u]) dfs2(son[u], tp);
for (long long v : g[u]) {
if (v == fa[u] || v == son[u]) continue;
dfs2(v, v);
}
ed[u] = timer;
}
long long LCA(long long x, long long y) {
while (top[x] != top[y]) {
if (dep[top[x]] < dep[top[y]]) x ^= y ^= x ^= y;
x = fa[top[x]];
}
return dep[x] < dep[y] ? x : y;
}
long long findnex(long long u, long long f) {
long long res = 0;
while (top[u] != top[f]) u = fa[res = top[u]];
return u == f ? res : son[f];
}
void pushup(long long p) { val[p] = val[(p << 1)] + val[(p << 1 | 1)]; }
void build(long long l, long long r, long long p) {
if (l == r) return val[p] = a[rev[l]], void();
long long mid = (l + r) >> 1;
build(l, mid, (p << 1)), build(mid + 1, r, (p << 1 | 1));
pushup(p);
}
void pushdown(long long p, long long l, long long r) {
if (tag[p]) {
long long mid = (l + r) >> 1;
tag[(p << 1)] += tag[p], val[(p << 1)] += tag[p] * (mid - l + 1);
tag[(p << 1 | 1)] += tag[p], val[(p << 1 | 1)] += tag[p] * (r - mid);
tag[p] = 0;
}
}
void update(long long ql, long long qr, long long l, long long r, long long k,
long long p) {
if (ql <= l && r <= qr) return tag[p] += k, val[p] += k * (r - l + 1), void();
pushdown(p, l, r);
long long mid = (l + r) >> 1;
if (ql <= mid) update(ql, qr, l, mid, k, (p << 1));
if (qr > mid) update(ql, qr, mid + 1, r, k, (p << 1 | 1));
pushup(p);
}
long long query(long long ql, long long qr, long long l, long long r,
long long p) {
if (ql <= l && r <= qr) return val[p];
long long mid = (l + r) >> 1, res = 0;
pushdown(p, l, r);
if (ql <= mid) res += query(ql, qr, l, mid, (p << 1));
if (qr > mid) res += query(ql, qr, mid + 1, r, (p << 1 | 1));
return res;
}
void modify(long long x, long long z) {
if (x == root)
update(1, n, 1, n, z, 1);
else {
long long lca = LCA(root, x);
if (lca != x)
update(st[x], ed[x], 1, n, z, 1);
else {
long long t = findnex(root, x);
if (st[t] != 1) update(1, st[t] - 1, 1, n, z, 1);
if (ed[t] != n) update(ed[t] + 1, n, 1, n, z, 1);
}
}
}
long long ask(long long x) {
if (x == root)
return query(1, n, 1, n, 1);
else {
long long lca = LCA(root, x);
if (lca != x)
return query(st[x], ed[x], 1, n, 1);
else {
long long t = findnex(root, x), res = 0;
if (st[t] != 1) res += query(1, st[t] - 1, 1, n, 1);
if (ed[t] != n) res += query(ed[t] + 1, n, 1, n, 1);
return res;
}
}
}
long long dis(long long x, long long y) {
return dep[x] + dep[y] - (dep[LCA(x, y)] << 1);
}
long long LCA_ex(long long x, long long y) {
long long f = LCA(x, y), g = LCA(x, root), h = LCA(y, root), res = f;
if (dep[g] > dep[res]) res = g;
if (dep[h] > dep[res]) res = h;
return res;
}
signed main() {
n = rd(), m = rd();
for (long long i = 1; i <= n; ++i) a[i] = rd();
for (long long i = 1; i < n; ++i) {
long long x = rd(), y = rd();
g[x].push_back(y), g[y].push_back(x);
}
dfs1(1, 0), dfs2(1, 1), build(1, n, 1);
while (m--) {
long long opt = rd(), x = rd(), y, z;
if (opt == 1)
root = x;
else if (opt == 2)
y = rd(), z = rd(), modify(LCA_ex(x, y), z);
else
printf("%lld\n", ask(x));
}
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
A tourist hiked along the mountain range. The hike lasted for n days, during each day the tourist noted height above the sea level. On the i-th day height was equal to some integer hi. The tourist pick smooth enough route for his hike, meaning that the between any two consecutive days height changes by at most 1, i.e. for all i's from 1 to n - 1 the inequality |hi - hi + 1| ≤ 1 holds.
At the end of the route the tourist rafted down a mountain river and some notes in the journal were washed away. Moreover, the numbers in the notes could have been distorted. Now the tourist wonders what could be the maximum height during his hike. Help him restore the maximum possible value of the maximum height throughout the hike or determine that the notes were so much distorted that they do not represent any possible height values that meet limits |hi - hi + 1| ≤ 1.
Input
The first line contains two space-separated numbers, n and m (1 ≤ n ≤ 108, 1 ≤ m ≤ 105) — the number of days of the hike and the number of notes left in the journal.
Next m lines contain two space-separated integers di and hdi (1 ≤ di ≤ n, 0 ≤ hdi ≤ 108) — the number of the day when the i-th note was made and height on the di-th day. It is guaranteed that the notes are given in the chronological order, i.e. for all i from 1 to m - 1 the following condition holds: di < di + 1.
Output
If the notes aren't contradictory, print a single integer — the maximum possible height value throughout the whole route.
If the notes do not correspond to any set of heights, print a single word 'IMPOSSIBLE' (without the quotes).
Examples
Input
8 2
2 0
7 0
Output
2
Input
8 3
2 0
7 0
8 3
Output
IMPOSSIBLE
Note
For the first sample, an example of a correct height sequence with a maximum of 2: (0, 0, 1, 2, 1, 1, 0, 1).
In the second sample the inequality between h7 and h8 does not hold, thus the information is inconsistent.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long kx[] = {2, -2, 2, -2, 1, -1, 1, -1};
long ky[] = {1, 1, -1, -1, 2, 2, -2, -2};
long dx[] = {1, -1, 0, 0, 1, -1, 1, -1};
long dy[] = {0, 0, 1, -1, 1, 1, -1, -1};
const long INF = (1e9);
inline long MOD(long a, long b) {
long res = a % b;
return res < 0 ? res + abs(b) : res;
}
inline long Pow(long base, long exp) {
long res = 1;
while (exp > 0) {
if (exp & 1) res *= base;
exp >>= 1;
base *= base;
}
return res;
}
inline long Log(long base, long n) {
long ans = (long)(floor(log10((double)n) / log10((double)base)) + 1e-7);
return ans;
}
inline long BigMod(long base, long exp, long M) {
base = MOD(base, M);
long res = 1;
while (exp > 0) {
if (exp & 1) res = MOD(res * base, M);
exp >>= 1;
base = MOD(base * base, M);
}
return res;
}
long d[100009], h[100009];
int main() {
long g, x, y, z, i, j, k, l, m, n, p, q, r, u, v, w, t, cas, edge, node, a, b,
c, e, f, ans, cnt, ass;
while (scanf("%ld %ld", &n, &m) == 2) {
for (i = 0; i < m; i++) scanf("%ld %ld", &d[i], &h[i]);
long Max = h[0];
k = 0;
for (i = 0; i < m - 1; i++) {
g = d[i + 1] - d[i];
if (h[i + 1] > h[i] + g || h[i + 1] < h[i] - g) {
k = 1;
break;
}
ans = min(h[i + 1], h[i]) + (g + abs(h[i + 1] - h[i])) / 2;
Max = max(Max, ans);
}
if (k)
puts("IMPOSSIBLE");
else {
if (d[0] > 1) {
Max = max(Max, d[0] - 1 + h[0]);
}
if (d[m - 1] < n) {
Max = max(Max, n - d[m - 1] + h[m - 1]);
}
printf("%ld\n", Max);
}
}
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
Long time ago, there was a great kingdom and it was being ruled by The Great Arya and Pari The Great. These two had some problems about the numbers they like, so they decided to divide the great kingdom between themselves.
The great kingdom consisted of n cities numbered from 1 to n and m bidirectional roads between these cities, numbered from 1 to m. The i-th road had length equal to wi. The Great Arya and Pari The Great were discussing about destructing some prefix (all road with numbers less than some x) and suffix (all roads with numbers greater than some x) of the roads so there will remain only the roads with numbers l, l + 1, ..., r - 1 and r.
After that they will divide the great kingdom into two pieces (with each city belonging to exactly one piece) such that the hardness of the division is minimized. The hardness of a division is the maximum length of a road such that its both endpoints are in the same piece of the kingdom. In case there is no such road, the hardness of the division is considered to be equal to - 1.
Historians found the map of the great kingdom, and they have q guesses about the l and r chosen by those great rulers. Given these data, for each guess li and ri print the minimum possible hardness of the division of the kingdom.
Input
The first line of the input contains three integers n, m and q (1 ≤ n, q ≤ 1000, <image>) — the number of cities and roads in the great kingdom, and the number of guesses, respectively.
The i-th line of the following m lines contains three integers ui, vi and wi (1 ≤ ui, vi ≤ n, 0 ≤ wi ≤ 109), denoting the road number i connects cities ui and vi and its length is equal wi. It's guaranteed that no road connects the city to itself and no pair of cities is connected by more than one road.
Each of the next q lines contains a pair of integers li and ri (1 ≤ li ≤ ri ≤ m) — a guess from the historians about the remaining roads in the kingdom.
Output
For each guess print the minimum possible hardness of the division in described scenario.
Example
Input
5 6 5
5 4 86
5 1 0
1 3 38
2 1 33
2 4 28
2 3 40
3 5
2 6
1 3
2 3
1 6
Output
-1
33
-1
-1
33
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int id[600000], a[600000], b[600000], c[600000];
bool cmp(int i, int j) { return c[i] > c[j]; }
int adj[1010][1010], deg[1010], col[1010], root[1010];
int main() {
int n, m, q;
cin >> n >> m >> q;
for (int i = 0; i < m; i++) {
scanf("%d %d %d", a + i, b + i, c + i);
id[i] = i;
}
sort(id, id + m, cmp);
int L, R;
while (q--) {
scanf("%d %d", &L, &R);
L--;
R--;
for (int i = 1; i <= n; i++) {
root[i] = i;
col[i] = deg[i] = 0;
adj[i][deg[i]++] = i;
}
int ans = -1;
for (int ii = 0; ii < m; ii++) {
int i = id[ii];
if (i > R || i < L) continue;
int x = root[a[i]], y = root[b[i]];
if (x == y) {
if (col[a[i]] == col[b[i]]) {
ans = c[i];
break;
}
} else {
if (deg[x] > deg[y]) swap(x, y);
int inv = (col[a[i]] == col[b[i]]);
for (int j = 0; j < deg[x]; j++) {
int z = adj[x][j];
adj[y][deg[y]++] = z;
root[z] = y;
col[z] ^= inv;
}
}
}
printf("%d\n", ans);
}
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
Autocomplete is a program function that enables inputting the text (in editors, command line shells, browsers etc.) completing the text by its inputted part. Vasya is busy working on a new browser called 'BERowser'. He happens to be working on the autocomplete function in the address line at this very moment. A list consisting of n last visited by the user pages and the inputted part s are known. Your task is to complete s to make it an address of one of the pages from the list. You have to find the lexicographically smallest address having a prefix s.
Input
The first line contains the s line which is the inputted part. The second line contains an integer n (1 ≤ n ≤ 100) which is the number of visited pages. Then follow n lines which are the visited pages, one on each line. All the lines have lengths of from 1 to 100 symbols inclusively and consist of lowercase Latin letters only.
Output
If s is not the beginning of any of n addresses of the visited pages, print s. Otherwise, print the lexicographically minimal address of one of the visited pages starting from s.
The lexicographical order is the order of words in a dictionary. The lexicographical comparison of lines is realized by the '<' operator in the modern programming languages.
Examples
Input
next
2
nextpermutation
nextelement
Output
nextelement
Input
find
4
find
findfirstof
findit
fand
Output
find
Input
find
4
fondfind
fondfirstof
fondit
fand
Output
find
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int n;
cin >> n;
string vis[n];
for (int i = 0; i < n; i++) {
cin >> vis[i];
}
for (int i = 0; i < n; i++) {
string t = vis[i].substr(0, s.size());
if (s == t && vis[i].size() == s.size()) {
cout << s;
return 0;
}
}
int a = 0;
for (int i = 0; i < n; i++) {
string t = vis[i].substr(0, s.size());
if (s == t) {
a++;
}
}
if (a == 0) {
cout << s;
return 0;
}
string res = " ";
for (int i = 0; i < n; i++) {
string t = vis[i].substr(0, s.size());
if (s == t) {
int x = vis[i].size() - s.size();
if (res == " ") {
res = vis[i];
} else {
int n = res.compare(vis[i]);
if (n > 0) res = vis[i];
}
}
}
cout << res;
return 0;
cout << n;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Igor is in the museum and he wants to see as many pictures as possible.
Museum can be represented as a rectangular field of n × m cells. Each cell is either empty or impassable. Empty cells are marked with '.', impassable cells are marked with '*'. Every two adjacent cells of different types (one empty and one impassable) are divided by a wall containing one picture.
At the beginning Igor is in some empty cell. At every moment he can move to any empty cell that share a side with the current one.
For several starting positions you should calculate the maximum number of pictures that Igor can see. Igor is able to see the picture only if he is in the cell adjacent to the wall with this picture. Igor have a lot of time, so he will examine every picture he can see.
Input
First line of the input contains three integers n, m and k (3 ≤ n, m ≤ 1000, 1 ≤ k ≤ min(n·m, 100 000)) — the museum dimensions and the number of starting positions to process.
Each of the next n lines contains m symbols '.', '*' — the description of the museum. It is guaranteed that all border cells are impassable, so Igor can't go out from the museum.
Each of the last k lines contains two integers x and y (1 ≤ x ≤ n, 1 ≤ y ≤ m) — the row and the column of one of Igor's starting positions respectively. Rows are numbered from top to bottom, columns — from left to right. It is guaranteed that all starting positions are empty cells.
Output
Print k integers — the maximum number of pictures, that Igor can see if he starts in corresponding position.
Examples
Input
5 6 3
******
*..*.*
******
*....*
******
2 2
2 5
4 3
Output
6
4
10
Input
4 4 1
****
*..*
*.**
****
3 2
Output
8
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000 + 10;
const int dx[] = {0, 0, 1, -1}, dy[] = {1, -1, 0, 0};
int n, m, k, vis[maxn][maxn], col, ans[maxn * maxn];
char s[maxn][maxn];
struct node {
int x, y;
};
queue<node> q;
int bfs(node st) {
int ret = 0;
col++;
q.push(st);
vis[st.x][st.y] = col;
while (!q.empty()) {
node cs = q.front();
q.pop();
for (int i = 0; i <= 3; ++i) {
node ns = cs;
ns.x += dx[i];
ns.y += dy[i];
if (ns.x < 1 || ns.y < 1 || ns.x > n || ns.y > m || vis[ns.x][ns.y])
continue;
if (s[ns.x][ns.y] == '*') {
ret++;
continue;
}
vis[ns.x][ns.y] = col;
q.push(ns);
}
}
ans[col] = ret;
return ret;
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; ++i) {
scanf("%s", s[i] + 1);
}
for (int i = 1; i <= k; ++i) {
node cs;
scanf("%d%d", &cs.x, &cs.y);
if (vis[cs.x][cs.y])
printf("%d\n", ans[vis[cs.x][cs.y]]);
else
printf("%d\n", bfs(cs));
}
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
Little C loves number «3» very much. He loves all things about it.
Now he has a positive integer n. He wants to split n into 3 positive integers a,b,c, such that a+b+c=n and none of the 3 integers is a multiple of 3. Help him to find a solution.
Input
A single line containing one integer n (3 ≤ n ≤ 10^9) — the integer Little C has.
Output
Print 3 positive integers a,b,c in a single line, such that a+b+c=n and none of them is a multiple of 3.
It can be proved that there is at least one solution. If there are multiple solutions, print any of them.
Examples
Input
3
Output
1 1 1
Input
233
Output
77 77 79
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n;
cin >> n;
if ((n - 2) % 3) {
cout << 1 << " " << 1 << " " << n - 2 << '\n';
} else {
cout << 1 << " " << 2 << " " << n - 3 << '\n';
}
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1;
while (t--) {
solve();
}
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
It has been noted that if some ants are put in the junctions of the graphene integer lattice then they will act in the following fashion: every minute at each junction (x, y) containing at least four ants a group of four ants will be formed, and these four ants will scatter to the neighbouring junctions (x + 1, y), (x - 1, y), (x, y + 1), (x, y - 1) — one ant in each direction. No other ant movements will happen. Ants never interfere with each other.
Scientists have put a colony of n ants into the junction (0, 0) and now they wish to know how many ants will there be at some given junctions, when the movement of the ants stops.
Input
First input line contains integers n (0 ≤ n ≤ 30000) and t (1 ≤ t ≤ 50000), where n is the number of ants in the colony and t is the number of queries. Each of the next t lines contains coordinates of a query junction: integers xi, yi ( - 109 ≤ xi, yi ≤ 109). Queries may coincide.
It is guaranteed that there will be a certain moment of time when no possible movements can happen (in other words, the process will eventually end).
Output
Print t integers, one per line — the number of ants at the corresponding junctions when the movement of the ants stops.
Examples
Input
1 3
0 1
0 0
0 -1
Output
0
1
0
Input
6 5
0 -2
0 -1
0 0
0 1
0 2
Output
0
1
2
1
0
Note
In the first sample the colony consists of the one ant, so nothing happens at all.
In the second sample the colony consists of 6 ants. At the first minute 4 ants scatter from (0, 0) to the neighbouring junctions. After that the process stops.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int a[200][200];
int main() {
int n, t;
cin >> n >> t;
a[100][100] = n;
bool b = 1;
while (b) {
b = 0;
for (int x = 1; x < 200 - 1; x++) {
for (int y = 1; y < 200 - 1; y++) {
if (a[x][y] >= 4) {
a[x - 1][y] += a[x][y] / 4;
a[x][y - 1] += a[x][y] / 4;
a[x + 1][y] += a[x][y] / 4;
a[x][y + 1] += a[x][y] / 4;
b = 1;
a[x][y] %= 4;
}
}
}
}
for (int x = 0; x < t; x++) {
int c, d;
cin >> c >> d;
if (abs(c) >= 90 || abs(d) >= 90)
cout << 0 << endl;
else
cout << a[c + 100][d + 100] << endl;
}
}
``` |
### Prompt
Generate a CPP solution to the following problem:
Vladimir wants to modernize partitions in his office. To make the office more comfortable he decided to remove a partition and plant several bamboos in a row. He thinks it would be nice if there are n bamboos in a row, and the i-th from the left is ai meters high.
Vladimir has just planted n bamboos in a row, each of which has height 0 meters right now, but they grow 1 meter each day. In order to make the partition nice Vladimir can cut each bamboo once at any height (no greater that the height of the bamboo), and then the bamboo will stop growing.
Vladimir wants to check the bamboos each d days (i.e. d days after he planted, then after 2d days and so on), and cut the bamboos that reached the required height. Vladimir wants the total length of bamboo parts he will cut off to be no greater than k meters.
What is the maximum value d he can choose so that he can achieve what he wants without cutting off more than k meters of bamboo?
Input
The first line contains two integers n and k (1 ≤ n ≤ 100, 1 ≤ k ≤ 1011) — the number of bamboos and the maximum total length of cut parts, in meters.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109) — the required heights of bamboos, in meters.
Output
Print a single integer — the maximum value of d such that Vladimir can reach his goal.
Examples
Input
3 4
1 3 5
Output
3
Input
3 40
10 30 50
Output
32
Note
In the first example Vladimir can check bamboos each 3 days. Then he will cut the first and the second bamboos after 3 days, and the third bamboo after 6 days. The total length of cut parts is 2 + 0 + 1 = 3 meters.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int N;
long long K;
vector<long long> arr;
vector<long long> le, ri;
int main() {
scanf("%d %lld", &N, &K);
arr.resize(N);
for (int i = 0; i < N; i++) {
scanf("%lld", &arr[i]);
}
long long ans = 1;
for (int d = 2; d <= 100010; d++) {
long long sum = 0;
for (int j = 0; j < N; j++) {
long long q = (arr[j] + d - 1) / d;
sum += q * d - arr[j];
}
if (sum <= K) ans = d;
}
for (int i = 0; i < N; i++) {
for (int j = 1; j <= 10010; j++) {
long long s = 1, e = 1e15;
long long x = -1;
while (s <= e) {
long long m = (s + e) >> 1;
if ((arr[i] + m - 1) / m >= j) {
x = m;
s = m + 1;
} else
e = m - 1;
}
if (x != -1) ri.push_back(x);
}
}
ri.push_back(0);
ri.push_back(1e15);
sort(ri.begin(), ri.end());
ri.resize(unique(ri.begin(), ri.end()) - ri.begin());
for (int i = 0; i < (int)ri.size() - 1; i++) {
long long s = ri[i] + 1;
long long e = ri[i + 1];
long long t = s;
long long sum = 0;
long long qsum = 0;
for (int j = 0; j < N; j++) {
long long q = (arr[j] + t - 1) / t;
sum += q * t - arr[j];
qsum += q;
}
long long x = -1;
while (s <= e) {
long long m = (s + e) >> 1;
if (sum + (m - t) * qsum <= K) {
x = m;
s = m + 1;
} else
e = m - 1;
}
ans = max(ans, x);
}
printf("%lld", ans);
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
Alyona has a tree with n vertices. The root of the tree is the vertex 1. In each vertex Alyona wrote an positive integer, in the vertex i she wrote ai. Moreover, the girl wrote a positive integer to every edge of the tree (possibly, different integers on different edges).
Let's define dist(v, u) as the sum of the integers written on the edges of the simple path from v to u.
The vertex v controls the vertex u (v ≠ u) if and only if u is in the subtree of v and dist(v, u) ≤ au.
Alyona wants to settle in some vertex. In order to do this, she wants to know for each vertex v what is the number of vertices u such that v controls u.
Input
The first line contains single integer n (1 ≤ n ≤ 2·105).
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109) — the integers written in the vertices.
The next (n - 1) lines contain two integers each. The i-th of these lines contains integers pi and wi (1 ≤ pi ≤ n, 1 ≤ wi ≤ 109) — the parent of the (i + 1)-th vertex in the tree and the number written on the edge between pi and (i + 1).
It is guaranteed that the given graph is a tree.
Output
Print n integers — the i-th of these numbers should be equal to the number of vertices that the i-th vertex controls.
Examples
Input
5
2 5 1 4 6
1 7
1 1
3 5
3 6
Output
1 0 1 0 0
Input
5
9 7 8 6 5
1 1
2 1
3 1
4 1
Output
4 3 2 1 0
Note
In the example test case the vertex 1 controls the vertex 3, the vertex 3 controls the vertex 5 (note that is doesn't mean the vertex 1 controls the vertex 5).
### Response
```cpp
#include <bits/stdc++.h>
const int X = 500000;
using namespace std;
int n, idx[X], pcnt;
long long a[X], w[X], pre[X], d[X], ans[X];
vector<int> g[X];
void Dfs(int u) {
int id = lower_bound(pre, pre + pcnt + 1, pre[pcnt] - a[u]) - pre;
d[idx[id - 1]]--;
d[idx[pcnt - 1]]++;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
pre[pcnt + 1] = pre[pcnt] + w[v];
idx[pcnt + 1] = v;
pcnt++;
Dfs(v);
pcnt--;
}
}
void Dfs2(int u) {
ans[u] = d[u];
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
Dfs2(v);
ans[u] += ans[v];
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%I64d", &a[i]);
for (int v = 2; v <= n; v++) {
int u;
scanf("%d%I64d", &u, &w[v]);
g[u].push_back(v);
}
idx[0] = 1;
Dfs(1);
ans[1] = d[1];
Dfs2(1);
for (int i = 1; i <= n; i++) printf("%I64d ", ans[i]);
puts(" ");
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
You are given two integer sequences of length N: a_1,a_2,..,a_N and b_1,b_2,..,b_N. Determine if we can repeat the following operation zero or more times so that the sequences a and b become equal.
Operation: Choose two integers i and j (possibly the same) between 1 and N (inclusive), then perform the following two actions simultaneously:
* Add 2 to a_i.
* Add 1 to b_j.
Constraints
* 1 ≤ N ≤ 10 000
* 0 ≤ a_i,b_i ≤ 10^9 (1 ≤ i ≤ N)
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
a_1 a_2 .. a_N
b_1 b_2 .. b_N
Output
If we can repeat the operation zero or more times so that the sequences a and b become equal, print `Yes`; otherwise, print `No`.
Examples
Input
3
1 2 3
5 2 2
Output
Yes
Input
5
3 1 4 1 5
2 7 1 8 2
Output
No
Input
5
2 7 1 8 2
3 1 4 1 5
Output
No
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 10005;
int a[N], b[N];
int n;
long long ans;
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i <= n; ++i) cin >> b[i];
for (int i = 1; i <= n; ++i) {
int c = b[i] - a[i];
if (c < 0) ans += c;
else ans += c / 2;
}
if (ans < 0) cout << "No\n";
else cout << "Yes\n";
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
Petya and Vasya are tossing a coin. Their friend Valera is appointed as a judge. The game is very simple. First Vasya tosses a coin x times, then Petya tosses a coin y times. If the tossing player gets head, he scores one point. If he gets tail, nobody gets any points. The winner is the player with most points by the end of the game. If boys have the same number of points, the game finishes with a draw.
At some point, Valera lost his count, and so he can not say exactly what the score is at the end of the game. But there are things he remembers for sure. He remembers that the entire game Vasya got heads at least a times, and Petya got heads at least b times. Moreover, he knows that the winner of the game was Vasya. Valera wants to use this information to know every possible outcome of the game, which do not contradict his memories.
Input
The single line contains four integers x, y, a, b (1 ≤ a ≤ x ≤ 100, 1 ≤ b ≤ y ≤ 100). The numbers on the line are separated by a space.
Output
In the first line print integer n — the number of possible outcomes of the game. Then on n lines print the outcomes. On the i-th line print a space-separated pair of integers ci, di — the number of heads Vasya and Petya got in the i-th outcome of the game, correspondingly. Print pairs of integers (ci, di) in the strictly increasing order.
Let us remind you that the pair of numbers (p1, q1) is less than the pair of numbers (p2, q2), if p1 < p2, or p1 = p2 and also q1 < q2.
Examples
Input
3 2 1 1
Output
3
2 1
3 1
3 2
Input
2 4 2 2
Output
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y, a, b;
cin >> x >> y >> a >> b;
vector<pair<int, int>> v;
for (int i = a; i <= x; ++i) {
for (int j = b; j <= y && j < i; ++j) {
v.push_back(pair<int, int>(i, j));
}
}
cout << v.size() << "\n";
for (int i = 0; i < v.size(); ++i) {
cout << v[i].first << " " << v[i].second << "\n";
}
return 0;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
Genos has been given n distinct lines on the Cartesian plane. Let <image> be a list of intersection points of these lines. A single point might appear multiple times in this list if it is the intersection of multiple pairs of lines. The order of the list does not matter.
Given a query point (p, q), let <image> be the corresponding list of distances of all points in <image> to the query point. Distance here refers to euclidean distance. As a refresher, the euclidean distance between two points (x1, y1) and (x2, y2) is <image>.
Genos is given a point (p, q) and a positive integer m. He is asked to find the sum of the m smallest elements in <image>. Duplicate elements in <image> are treated as separate elements. Genos is intimidated by Div1 E problems so he asked for your help.
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 50 000) — the number of lines.
The second line contains three integers x, y and m (|x|, |y| ≤ 1 000 000, <image>) — the encoded coordinates of the query point and the integer m from the statement above. The query point (p, q) is obtained as <image>. In other words, divide x and y by 1000 to get the actual query point. <image> denotes the length of the list <image> and it is guaranteed that <image>.
Each of the next n lines contains two integers ai and bi (|ai|, |bi| ≤ 1 000 000) — the parameters for a line of the form: <image>. It is guaranteed that no two lines are the same, that is (ai, bi) ≠ (aj, bj) if i ≠ j.
Output
Print a single real number, the sum of m smallest elements of <image>. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
To clarify, 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
4
1000 1000 3
1000 0
-1000 0
0 5000
0 -5000
Output
14.282170363
Input
2
-1000000 -1000000 1
1000000 -1000000
999999 1000000
Output
2000001000.999999500
Input
3
-1000 1000 3
1000 0
-1000 2000
2000 -1000
Output
6.000000000
Input
5
-303667 189976 10
-638 116487
-581 44337
1231 -756844
1427 -44097
8271 -838417
Output
12953.274911829
Note
In the first sample, the three closest points have distances <image> and <image>.
In the second sample, the two lines y = 1000x - 1000 and <image> intersect at (2000000, 1999999000). This point has a distance of <image> from ( - 1000, - 1000).
In the third sample, the three lines all intersect at the point (1, 1). This intersection point is present three times in <image> since it is the intersection of three pairs of lines. Since the distance between the intersection point and the query point is 2, the answer is three times that or 6.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-6, pi = acos(-1.00);
int n, m;
double cx, cy, ans;
struct line {
double a, b;
};
line lines[55555];
struct segment {
double ltheta, rtheta;
int id;
bool operator<(const segment &temp) const { return ltheta < temp.ltheta; }
};
segment sg[55555];
struct pp {
int flag, id, nx;
double theta;
bool operator<(const pp &temp) const {
if (theta == temp.theta) return flag < temp.flag;
return theta < temp.theta;
}
};
pp xx[110000];
struct qq {
int id, ip;
bool operator<(const qq &temp) const { return ip < temp.ip; }
};
set<qq> hs;
set<qq>::iterator it;
qq now;
int nxt[55555], pre[55555];
int cnt_sg, cnt_x, ix[155555], rt[110000];
int cnt_th;
int arr[110000];
void norm(double &theta) {
while (theta <= -pi) theta += 2 * pi;
while (theta > pi) theta -= 2 * pi;
}
int lowbit(int x) { return x & (-x); }
void insert(int id) {
int flag = xx[id].flag;
for (id = rt[xx[id].id] + 1; id <= cnt_x; id += lowbit(id)) arr[id] -= flag;
}
int query(int id) {
int res = 0;
for (id = rt[xx[id].id] + 1; id > 0; id -= lowbit(id)) res += arr[id];
return res;
}
int check(double r, bool path_fou) {
int res = 0, id, i, j, s, p, q;
double alpha, theta, vv;
cnt_sg = 0;
for (i = 0; i < n; i++) {
alpha = atan2(1., lines[i].a);
vv = (cy - lines[i].b - lines[i].a * cx) /
(r * sqrt(1 + lines[i].a * lines[i].a));
if (vv < -1 || vv > 1) continue;
theta = -acos(vv) - alpha;
norm(theta);
sg[cnt_sg].id = i;
sg[cnt_sg].ltheta = theta;
theta = acos(vv) - alpha;
norm(theta);
sg[cnt_sg++].rtheta = theta;
if (sg[cnt_sg - 1].ltheta > sg[cnt_sg - 1].rtheta)
swap(sg[cnt_sg - 1].ltheta, sg[cnt_sg - 1].rtheta);
}
cnt_x = 0;
for (i = 0; i < cnt_sg; i++) {
xx[cnt_x].theta = sg[i].ltheta;
xx[cnt_x].id = i;
xx[cnt_x++].flag = -1;
xx[cnt_x].theta = sg[i].rtheta;
xx[cnt_x].id = i;
xx[cnt_x++].flag = 1;
}
sort(xx, xx + cnt_x);
for (i = 0; i < cnt_x; i++) rt[xx[i].id] = i;
for (i = 0; i <= cnt_x; i++) arr[i] = 0;
for (i = 0; i < cnt_x; i++) {
if (xx[i].flag < 0) {
res += query(i);
if (!path_fou) {
if (res > m) return 1;
}
}
insert(i);
}
if (!path_fou) {
if (res < m) return -1;
}
if (path_fou) {
memset(nxt, -1, sizeof(nxt));
memset(pre, -1, sizeof(pre));
hs.clear();
ans = 0;
for (i = 0; i < cnt_x; i++) {
now.id = sg[xx[i].id].id;
now.ip = rt[xx[i].id];
it = hs.upper_bound(now);
if (xx[i].flag < 0) {
if (it != hs.end()) {
nxt[now.id] = it->id;
pre[it->id] = now.id;
}
if (it != hs.begin()) {
it--;
id = it->id;
while (id >= 0) {
int ii = now.id, jj = id;
double xp, yp;
xp = (lines[jj].b - lines[ii].b) / (lines[ii].a - lines[jj].a);
yp = lines[ii].a * xp + lines[ii].b;
ans += sqrt((cx - xp) * (cx - xp) + (cy - yp) * (cy - yp));
m--;
id = pre[id];
}
nxt[it->id] = now.id;
pre[now.id] = it->id;
}
hs.insert(now);
} else {
if (nxt[now.id] >= 0) pre[nxt[now.id]] = pre[now.id];
if (pre[now.id] >= 0) nxt[pre[now.id]] = nxt[now.id];
pre[now.id] = -1;
nxt[now.id] = -1;
hs.erase(now);
}
}
}
return 0;
}
int main() {
int i, j, s, p, q;
double low, high, mid;
scanf("%d%lf%lf%d", &n, &cx, &cy, &m);
cx /= 1000.;
cy /= 1000.;
for (i = 0; i < n; i++) {
scanf("%lf%lf", &lines[i].a, &lines[i].b);
lines[i].a /= 1000.;
lines[i].b /= 1000.;
}
low = 0;
high = 2e9 + 2e3;
for (int it = 0; it <= 50; it++) {
mid = (low + high) / 2.0;
int ms = check(mid, 0);
if (ms <= 0)
low = mid;
else if (ms > 0)
high = mid;
}
check(low, 1);
printf("%.20f\n", ans + low * m);
return 0;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
The sequence of integers a_1, a_2, ..., a_k is called a good array if a_1 = k - 1 and a_1 > 0. For example, the sequences [3, -1, 44, 0], [1, -99] are good arrays, and the sequences [3, 7, 8], [2, 5, 4, 1], [0] — are not.
A sequence of integers is called good if it can be divided into a positive number of good arrays. Each good array should be a subsegment of sequence and each element of the sequence should belong to exactly one array. For example, the sequences [2, -3, 0, 1, 4], [1, 2, 3, -3, -9, 4] are good, and the sequences [2, -3, 0, 1], [1, 2, 3, -3 -9, 4, 1] — are not.
For a given sequence of numbers, count the number of its subsequences that are good sequences, and print the number of such subsequences modulo 998244353.
Input
The first line contains the number n~(1 ≤ n ≤ 10^3) — the length of the initial sequence. The following line contains n integers a_1, a_2, ..., a_n~(-10^9 ≤ a_i ≤ 10^9) — the sequence itself.
Output
In the single line output one integer — the number of subsequences of the original sequence that are good sequences, taken modulo 998244353.
Examples
Input
3
2 1 1
Output
2
Input
4
1 1 1 1
Output
7
Note
In the first test case, two good subsequences — [a_1, a_2, a_3] and [a_2, a_3].
In the second test case, seven good subsequences — [a_1, a_2, a_3, a_4], [a_1, a_2], [a_1, a_3], [a_1, a_4], [a_2, a_3], [a_2, a_4] and [a_3, a_4].
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long int Maxn3 = 1e3 + 10;
const long long int Maxn4 = 1e4 + 10;
const long long int Maxn5 = 1e5 + 10;
const long long int Maxn6 = 1e6 + 10;
const long long int Maxn7 = 1e7 + 10;
const long long int Maxn8 = 1e8 + 10;
const long long int Maxn9 = 1e9 + 10;
const long long int Maxn18 = 1e18 + 10;
const long long int Mod1 = 1e7 + 7;
const long long int Mod2 = 1e9 + 7;
const long long int LLMax = LLONG_MAX;
const long long int LLMin = LLONG_MIN;
const long long int INTMax = INT_MAX;
const long long int INTMin = INT_MIN;
long long int mn = LLMax, mx = LLMin;
long long int dp[Maxn3], tmp[Maxn3];
int main() {
long long int n, mod = 998244353;
cin >> n;
dp[0] = 1;
for (long long int i = 0; i < n; i++) {
long long int d;
cin >> d;
memcpy(tmp, dp, sizeof(dp));
if (d > 0 and d <= n) tmp[d] = (tmp[d] + dp[0]) % mod;
for (long long int j = 0; j <= n; j++) tmp[j] = (tmp[j] + dp[j + 1]) % mod;
memcpy(dp, tmp, sizeof(tmp));
}
return cout << (dp[0] - 1 + mod) % mod, 0;
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
Hooray! Berl II, the king of Berland is making a knight tournament. The king has already sent the message to all knights in the kingdom and they in turn agreed to participate in this grand event.
As for you, you're just a simple peasant. There's no surprise that you slept in this morning and were late for the tournament (it was a weekend, after all). Now you are really curious about the results of the tournament. This time the tournament in Berland went as follows:
* There are n knights participating in the tournament. Each knight was assigned his unique number — an integer from 1 to n.
* The tournament consisted of m fights, in the i-th fight the knights that were still in the game with numbers at least li and at most ri have fought for the right to continue taking part in the tournament.
* After the i-th fight among all participants of the fight only one knight won — the knight number xi, he continued participating in the tournament. Other knights left the tournament.
* The winner of the last (the m-th) fight (the knight number xm) became the winner of the tournament.
You fished out all the information about the fights from your friends. Now for each knight you want to know the name of the knight he was conquered by. We think that the knight number b was conquered by the knight number a, if there was a fight with both of these knights present and the winner was the knight number a.
Write the code that calculates for each knight, the name of the knight that beat him.
Input
The first line contains two integers n, m (2 ≤ n ≤ 3·105; 1 ≤ m ≤ 3·105) — the number of knights and the number of fights. Each of the following m lines contains three integers li, ri, xi (1 ≤ li < ri ≤ n; li ≤ xi ≤ ri) — the description of the i-th fight.
It is guaranteed that the input is correct and matches the problem statement. It is guaranteed that at least two knights took part in each battle.
Output
Print n integers. If the i-th knight lost, then the i-th number should equal the number of the knight that beat the knight number i. If the i-th knight is the winner, then the i-th number must equal 0.
Examples
Input
4 3
1 2 1
1 3 3
1 4 4
Output
3 1 4 0
Input
8 4
3 5 4
3 7 6
2 8 8
1 8 1
Output
0 8 4 6 4 8 6 1
Note
Consider the first test case. Knights 1 and 2 fought the first fight and knight 1 won. Knights 1 and 3 fought the second fight and knight 3 won. The last fight was between knights 3 and 4, knight 4 won.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
pair<long long, long long> add_pair(pair<long long, long long> a,
pair<long long, long long> b) {
return make_pair(a.first + b.first, a.second + b.second);
}
bool cmp(pair<long long, long long> a, pair<long long, long long> b) {
if (a.first == b.first) return a.second > b.second;
return a.first < b.first;
}
long long power(long long a, long long b) {
long long res = 1;
a = a % 1000000007;
while (b > 0) {
if (b & 1) {
res = (res * a) % 1000000007;
b--;
}
a = (a * a) % 1000000007;
b = b >> 1;
}
return res;
}
long long fermat_inv(long long y) { return power(y, 1000000007 - 2); }
long long gcd(long long a, long long b) { return (b == 0) ? a : gcd(b, a % b); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long i, n, m, l, r, x;
cin >> n >> m;
set<long long> s;
long long win[n + 1];
for (i = 0; i < n; i += 1) s.insert(i + 1);
for (i = 0; i < m; i += 1) {
cin >> l >> r >> x;
win[x] = 0;
vector<long long> erase;
auto it = s.lower_bound(l);
for (; it != s.end() && (*it) <= r; it++) {
if ((*it) != x) {
win[(*it)] = x;
erase.push_back((*it));
}
}
for (auto jt = erase.begin(); jt != erase.end(); jt++) {
s.erase((*jt));
}
erase.clear();
}
for (i = 0; i < n; i += 1) cout << win[i + 1] << ' ';
cout << '\n';
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
Sereja has got an array, consisting of n integers, a1, a2, ..., an. Sereja is an active boy, so he is now going to complete m operations. Each operation will have one of the three forms:
1. Make vi-th array element equal to xi. In other words, perform the assignment avi = xi.
2. Increase each array element by yi. In other words, perform n assignments ai = ai + yi (1 ≤ i ≤ n).
3. Take a piece of paper and write out the qi-th array element. That is, the element aqi.
Help Sereja, complete all his operations.
Input
The first line contains integers n, m (1 ≤ n, m ≤ 105). The second line contains n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 109) — the original array.
Next m lines describe operations, the i-th line describes the i-th operation. The first number in the i-th line is integer ti (1 ≤ ti ≤ 3) that represents the operation type. If ti = 1, then it is followed by two integers vi and xi, (1 ≤ vi ≤ n, 1 ≤ xi ≤ 109). If ti = 2, then it is followed by integer yi (1 ≤ yi ≤ 104). And if ti = 3, then it is followed by integer qi (1 ≤ qi ≤ n).
Output
For each third type operation print value aqi. Print the values in the order, in which the corresponding queries follow in the input.
Examples
Input
10 11
1 2 3 4 5 6 7 8 9 10
3 2
3 9
2 10
3 1
3 10
1 1 10
2 10
2 10
3 1
3 10
3 9
Output
2
9
11
20
30
40
39
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n = 0, m = 0;
cin >> n >> m;
vector<int> array;
int temp = 0;
for (int i = 0; i < n; i++) {
cin >> temp;
array.push_back(temp);
}
int t = 0, v = 0, x = 0, y = 0, q = 0;
int accumy = 0;
for (int i = 0; i < m; i++) {
cin >> t;
if (t == 1) {
cin >> v;
cin >> x;
array[v - 1] = x - accumy;
}
if (t == 2) {
cin >> y;
accumy += y;
}
if (t == 3) {
cin >> q;
cout << array[q - 1] + accumy << endl;
}
}
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
Manao's friends often send him new songs. He never listens to them right away. Instead, he compiles them into a playlist. When he feels that his mind is open to new music, he opens the playlist and starts to listen to the songs.
Of course, there are some songs that Manao doesn't particuarly enjoy. To get more pleasure from the received songs, he invented the following procedure of listening to the playlist:
* If after listening to some song Manao realizes that he liked it, then he remembers it and starts to listen to the next unlistened song.
* If after listening to some song Manao realizes that he did not like it, he listens to all the songs he liked up to this point and then begins to listen to the next unlistened song.
For example, if Manao has four songs in the playlist, A, B, C, D (in the corresponding order) and he is going to like songs A and C in the end, then the order of listening is the following:
1. Manao listens to A, he likes it, he remembers it.
2. Manao listens to B, he does not like it, so he listens to A, again.
3. Manao listens to C, he likes the song and he remembers it, too.
4. Manao listens to D, but does not enjoy it and re-listens to songs A and C.
That is, in the end Manao listens to song A three times, to song C twice and songs B and D once. Note that if Manao once liked a song, he will never dislike it on a subsequent listening.
Manao has received n songs: the i-th of them is li seconds long and Manao may like it with a probability of pi percents. The songs could get on Manao's playlist in any order, so Manao wants to know the maximum expected value of the number of seconds after which the listening process will be over, for all possible permutations of the songs in the playlist.
Input
The first line contains a single integer n (1 ≤ n ≤ 50000). The i-th of the following n lines contains two integers, separated by a single space — li and pi (15 ≤ li ≤ 1000, 0 ≤ pi ≤ 100) — the length of the i-th song in seconds and the probability that Manao will like the song, in percents.
Output
In a single line print a single real number — the maximum expected listening time over all permutations of songs. The answer will be considered valid if the absolute or relative error does not exceed 10 - 9.
Examples
Input
3
150 20
150 50
100 50
Output
537.500000000
Input
4
300 0
300 50
240 50
360 80
Output
2121.000000000
Note
Consider the first test case. If Manao listens to the songs in the order in which they were originally compiled, the mathematical expectation will be equal to 467.5 seconds. The maximum expected value is obtained by putting the first song at the end of the playlist.
Consider the second test case. The song which is 360 seconds long should be listened to first. The song 300 seconds long which Manao will dislike for sure should be put in the end.
### Response
```cpp
#include <bits/stdc++.h>
const int Maxn = 50005;
int N, A[Maxn];
double L[Maxn], P[Maxn], Sum[Maxn], Ans;
using namespace std;
bool Cmp(const int &i, const int &j) {
return (L[i] * P[i] * (1 - P[j] / 100)) > (L[j] * P[j] * (1 - P[i] / 100));
}
int main() {
scanf("%d", &N);
for (int i = 1; i <= N; ++i) {
scanf("%lf%lf", &L[i], &P[i]);
A[i] = i;
}
sort(A + 1, A + 1 + N, Cmp);
for (int i = 1; i <= N; ++i) Sum[i] = Sum[i - 1] + L[A[i]] * P[A[i]];
for (int i = 1; i <= N; ++i) Ans += L[i] * 10000;
for (int i = 2; i <= N; ++i) Ans += (100 - P[A[i]]) * Sum[i - 1];
cout << setprecision(12) << setiosflags(ios ::fixed) << Ans / 10000 << endl;
return 0;
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
Vanya is in the palace that can be represented as a grid n × m. Each room contains a single chest, an the room located in the i-th row and j-th columns contains the chest of type aij. Each chest of type x ≤ p - 1 contains a key that can open any chest of type x + 1, and all chests of type 1 are not locked. There is exactly one chest of type p and it contains a treasure.
Vanya starts in cell (1, 1) (top left corner). What is the minimum total distance Vanya has to walk in order to get the treasure? Consider the distance between cell (r1, c1) (the cell in the row r1 and column c1) and (r2, c2) is equal to |r1 - r2| + |c1 - c2|.
Input
The first line of the input contains three integers n, m and p (1 ≤ n, m ≤ 300, 1 ≤ p ≤ n·m) — the number of rows and columns in the table representing the palace and the number of different types of the chests, respectively.
Each of the following n lines contains m integers aij (1 ≤ aij ≤ p) — the types of the chests in corresponding rooms. It's guaranteed that for each x from 1 to p there is at least one chest of this type (that is, there exists a pair of r and c, such that arc = x). Also, it's guaranteed that there is exactly one chest of type p.
Output
Print one integer — the minimum possible total distance Vanya has to walk in order to get the treasure from the chest of type p.
Examples
Input
3 4 3
2 1 1 1
1 1 1 1
2 1 1 3
Output
5
Input
3 3 9
1 3 5
8 9 7
4 6 2
Output
22
Input
3 4 12
1 2 3 4
8 7 6 5
9 10 11 12
Output
11
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct node {
int x;
int y;
int z;
node() {}
node(int x1, int y1, int z1) : x(x1), y(y1), z(z1) {}
};
int f[310][310];
int MAX = 2000000000;
vector<node> v[90010];
int main() {
int n, m, p;
cin >> n >> m >> p;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
int mid;
cin >> mid;
v[mid].push_back(node(i, j, MAX));
}
}
for (int i = 0; i < v[1].size(); ++i)
v[1][i].z = abs(1 - v[1][i].x) + abs(1 - v[1][i].y);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) f[i][j] = MAX;
for (int i = 1; i < p; ++i) {
for (int j = 0; j < v[i].size(); ++j)
for (int k = 1; k <= m; ++k)
f[v[i][j].x][k] = min(f[v[i][j].x][k], v[i][j].z + abs(k - v[i][j].y));
for (int j = 0; j < v[i + 1].size(); ++j)
for (int k = 1; k <= n; ++k)
v[i + 1][j].z =
min(v[i + 1][j].z, f[k][v[i + 1][j].y] + abs(k - v[i + 1][j].x));
for (int j = 0; j < v[i].size(); ++j)
for (int k = 1; k <= m; ++k) f[v[i][j].x][k] = MAX;
}
cout << v[p][0].z;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
There is a 120 minute videotape with standard recording. When I set the VCR counter to 00:00:00 with the tape completely rewound and recorded in standard recording mode, I got a certain counter value. Enter this counter value (hours, minutes, seconds), find the length of the remaining tape (recordable time), and create a program that outputs in the format of hours: minutes: seconds.
However, the input must be within 2 hours (120 minutes). The remaining amount of tape is calculated in two ways, standard recording mode and triple recording mode, and outputs two digits each for hours, minutes, and seconds as shown in the output example. If the tens digit is 0, such as "05", add "0".
input
Given multiple datasets. Each dataset is as follows.
T H S
T, H, and S are integers that represent hours, minutes, and seconds, respectively.
Input ends when T, H, and S are all -1. The number of datasets does not exceed 50.
output
For each dataset
On the first line, the hours, minutes, and seconds of the recordable time when the rest of the tape is recorded as standard, separated by half-width colons.
On the second line, the hours, minutes, and seconds of the recordable time when the rest of the tape is recorded three times are separated by half-width colons.
Please output.
Example
Input
1 30 0
-1 -1 -1
Output
00:30:00
01:30:00
### Response
```cpp
#include <iostream>
#include <cstdio>
#include <cstdlib>
using namespace std;
int main(){
int h,m,s;
while(1){
cin >> h >> m >> s;
if(h == -1 && m == -1 && s == -1)break;
int hms = 7200-(h*3600+m*60+s);
h = hms/3600;
hms-=3600*h;
m = hms/60;
hms-=60*m;
s = hms;
printf("%02d:%02d:%02d\n",h,m,s);
hms = 3*(h*3600+m*60+s);
h = hms/3600;
hms-=3600*h;
m = hms/60;
hms-=60*m;
s = hms;
printf("%02d:%02d:%02d\n",h,m,s);
}
}
``` |
### Prompt
Generate a cpp solution to the following problem:
Misha has an array of n integers indexed by integers from 1 to n. Let's define palindrome degree of array a as the number of such index pairs (l, r)(1 ≤ l ≤ r ≤ n), that the elements from the l-th to the r-th one inclusive can be rearranged in such a way that the whole array will be a palindrome. In other words, pair (l, r) should meet the condition that after some rearranging of numbers on positions from l to r, inclusive (it is allowed not to rearrange the numbers at all), for any 1 ≤ i ≤ n following condition holds: a[i] = a[n - i + 1].
Your task is to find the palindrome degree of Misha's array.
Input
The first line contains integer n (1 ≤ n ≤ 105).
The second line contains n positive integers a[i] (1 ≤ a[i] ≤ n), separated by spaces — the elements of Misha's array.
Output
In a single line print the answer to the problem.
Examples
Input
3
2 2 2
Output
6
Input
6
3 6 5 3 3 5
Output
0
Input
5
5 5 2 5 2
Output
4
Note
In the first sample test any possible pair (l, r) meets the condition.
In the third sample test following pairs (1, 3), (1, 4), (1, 5), (2, 5) meet the condition.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int a[100005], cnt[100005];
long long n;
bool in(int a, int b, int c) { return b <= a && a <= c; }
bool check(int l, int r, int mid) {
for (int i = 0; i < n; ++i) {
if (!in(i, 0, mid) && !in(n - i - 1, 0, mid) && a[i] != a[n - i - 1])
return false;
}
memset(cnt, 0, sizeof(cnt));
for (int i = 0; i < mid + 1; ++i) cnt[a[i]]++;
int start;
if (mid < (n) / 2)
start = n - mid - 1;
else
start = mid + 1;
for (int i = start; i < n; ++i) cnt[a[i]]--;
for (int i = 0; i <= n; ++i)
if (cnt[i] < 0) return false;
return true;
}
int main() {
memset(cnt, 0, sizeof(cnt));
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
cnt[a[i]]++;
}
int one = 0;
for (int i = 0; i <= n; ++i) {
if (cnt[i] % 2 == 1) one++;
}
if (one > 1) {
cout << 0 << endl;
return 0;
}
bool ok = true;
for (int i = 0; i < n; ++i) {
if (a[i] != a[n - i - 1]) {
ok = false;
break;
}
}
if (ok) {
cout << (n + 1) * n / 2 << endl;
return 0;
}
int left = 0;
for (int i = 0; i < n; ++i) {
if (a[i] != a[n - i - 1]) {
left = i;
break;
}
}
int l = left;
int r = n - l;
long long ans = 0;
int pos;
while (l < r) {
int mid = (l + r) / 2;
if (check(l, r, mid)) {
pos = mid;
r = mid;
} else {
l = mid + 1;
}
}
ans += (left + 1) * (n - pos);
for (int i = 0; i < n / 2; ++i) swap(a[i], a[n - i - 1]);
l = left;
r = n - left;
while (l < r) {
int mid = (l + r) / 2;
if (check(l, r, mid)) {
pos = mid;
r = mid;
} else {
l = mid + 1;
}
}
ans += (left + 1) * (n - pos);
ans -= (left + 1) * (left + 1);
cout << ans << endl;
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
Reforms continue entering Berland. For example, during yesterday sitting the Berland Parliament approved as much as n laws (each law has been assigned a unique number from 1 to n). Today all these laws were put on the table of the President of Berland, G.W. Boosch, to be signed.
This time mr. Boosch plans to sign 2k laws. He decided to choose exactly two non-intersecting segments of integers from 1 to n of length k and sign all laws, whose numbers fall into these segments. More formally, mr. Boosch is going to choose two integers a, b (1 ≤ a ≤ b ≤ n - k + 1, b - a ≥ k) and sign all laws with numbers lying in the segments [a; a + k - 1] and [b; b + k - 1] (borders are included).
As mr. Boosch chooses the laws to sign, he of course considers the public opinion. Allberland Public Opinion Study Centre (APOSC) conducted opinion polls among the citizens, processed the results into a report and gave it to the president. The report contains the absurdity value for each law, in the public opinion. As mr. Boosch is a real patriot, he is keen on signing the laws with the maximum total absurdity. Help him.
Input
The first line contains two integers n and k (2 ≤ n ≤ 2·105, 0 < 2k ≤ n) — the number of laws accepted by the parliament and the length of one segment in the law list, correspondingly. The next line contains n integers x1, x2, ..., xn — the absurdity of each law (1 ≤ xi ≤ 109).
Output
Print two integers a, b — the beginning of segments that mr. Boosch should choose. That means that the president signs laws with numbers from segments [a; a + k - 1] and [b; b + k - 1]. If there are multiple solutions, print the one with the minimum number a. If there still are multiple solutions, print the one with the minimum b.
Examples
Input
5 2
3 6 1 1 6
Output
1 4
Input
6 2
1 1 1 1 1 1
Output
1 3
Note
In the first sample mr. Boosch signs laws with numbers from segments [1;2] and [4;5]. The total absurdity of the signed laws equals 3 + 6 + 1 + 6 = 16.
In the second sample mr. Boosch signs laws with numbers from segments [1;2] and [3;4]. The total absurdity of the signed laws equals 1 + 1 + 1 + 1 = 4.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
inline long long int get() {
long long int c;
long long int n = 0;
while ((c = getchar()) >= '0' && c <= '9') n = (n << 3) + (n << 1) + c - '0';
return n;
}
string IntToString(int a) {
ostringstream temp;
temp << a;
return temp.str();
}
long long int powerwithmodulus(long long int base, long long int exponent,
long long int modulus) {
long long int result = 1;
base %= modulus;
while (exponent > 0) {
if (exponent % 2 == 1) result = (result * base) % modulus;
exponent = exponent >> 1;
base = (base * base) % modulus;
}
return result;
}
void printArray(int arr[], int n) {
for (size_t i = 0; i < n; i++) cout << arr[i] << " ";
cout << endl;
}
void printVector(std::vector<long long int> v) {
int n = v.size();
for (size_t i = 0; i < n; i++) cout << v[i] << " ";
cout << endl;
}
long long int largestPowerOf2(long long int n) {
return (long long int)pow(2, floor(log(n) / log(2)));
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long int n, k;
cin >> n >> k;
std::vector<long long int> v(n + 1);
for (int i = 1; i <= n; i++) cin >> v[i];
long long int val = 0;
for (int i = 1; i <= k; i++) val += v[i];
std::vector<long long int> sum;
sum.push_back(0);
sum.push_back(val);
for (int i = k + 1; i <= n; i++) {
val += v[i] - v[i - k];
sum.push_back(val);
}
std::vector<long long int> dp(sum.size(), 0);
dp[1] = 1;
for (int i = 2; i < dp.size(); i++) {
if (sum[i] > sum[dp[i - 1]]) {
dp[i] = i;
} else
dp[i] = dp[i - 1];
}
long long int ans = 0;
long long int st = 0, en = 0;
for (int i = k + 1; i < sum.size(); i++) {
if (ans < sum[i] + sum[dp[i - k]]) {
ans = sum[i] + sum[dp[i - k]];
st = dp[i - k], en = i;
}
}
cout << st << " " << en << endl;
return 0;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
There are K pieces of cakes. Mr. Takahashi would like to eat one cake per day, taking K days to eat them all.
There are T types of cake, and the number of the cakes of type i (1 ≤ i ≤ T) is a_i.
Eating the same type of cake two days in a row would be no fun, so Mr. Takahashi would like to decide the order for eating cakes that minimizes the number of days on which he has to eat the same type of cake as the day before.
Compute the minimum number of days on which the same type of cake as the previous day will be eaten.
Constraints
* 1 ≤ K ≤ 10000
* 1 ≤ T ≤ 100
* 1 ≤ a_i ≤ 100
* a_1 + a_2 + ... + a_T = K
Input
The input is given from Standard Input in the following format:
K T
a_1 a_2 ... a_T
Output
Print the minimum number of days on which the same type of cake as the previous day will be eaten.
Examples
Input
7 3
3 2 2
Output
0
Input
6 3
1 4 1
Output
1
Input
100 1
100
Output
99
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
signed main(){
int K, T; cin >> K >> T;
vector<int> a(T);
for(int i = 0; i < T; i++) cin >> a[i];
int x = *max_element(a.begin(), a.end());
int ans = max(0, 2*x - 1 - K);
cout << ans << endl;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
You are given three integers a ≤ b ≤ c.
In one move, you can add +1 or -1 to any of these integers (i.e. increase or decrease any number by one). You can perform such operation any (possibly, zero) number of times, you can even perform this operation several times with one number. Note that you cannot make non-positive numbers using such operations.
You have to perform the minimum number of such operations in order to obtain three integers A ≤ B ≤ C such that B is divisible by A and C is divisible by B.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
The next t lines describe test cases. Each test case is given on a separate line as three space-separated integers a, b and c (1 ≤ a ≤ b ≤ c ≤ 10^4).
Output
For each test case, print the answer. In the first line print res — the minimum number of operations you have to perform to obtain three integers A ≤ B ≤ C such that B is divisible by A and C is divisible by B. On the second line print any suitable triple A, B and C.
Example
Input
8
1 2 3
123 321 456
5 10 15
15 18 21
100 100 101
1 22 29
3 19 38
6 30 46
Output
1
1 1 3
102
114 228 456
4
4 8 16
6
18 18 18
1
100 100 100
7
1 22 22
2
1 19 38
8
6 24 48
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, i, j, a, b, c, k, A, B, C;
long long int mn = 100000000000, tmp;
cin >> a >> b >> c;
for (i = 1; i <= 20000; i++) {
for (j = i; j <= 20000; j += i) {
for (k = j; k <= 20000; k += j) {
tmp = abs(a - i) + abs(b - j) + abs(c - k);
if (tmp < mn) {
mn = tmp;
A = i, B = j, C = k;
}
}
}
}
cout << mn << endl;
cout << A << " " << B << " " << C << endl;
}
int main() {
int t;
cin >> t;
while (t--) solve();
}
``` |
### Prompt
Generate a CPP solution to the following problem:
Ahmed and Mostafa used to compete together in many programming contests for several years. Their coach Fegla asked them to solve one challenging problem, of course Ahmed was able to solve it but Mostafa couldn't.
This problem is similar to a standard problem but it has a different format and constraints.
In the standard problem you are given an array of integers, and you have to find one or more consecutive elements in this array where their sum is the maximum possible sum.
But in this problem you are given n small arrays, and you will create one big array from the concatenation of one or more instances of the small arrays (each small array could occur more than once). The big array will be given as an array of indexes (1-based) of the small arrays, and the concatenation should be done in the same order as in this array. Then you should apply the standard problem mentioned above on the resulting big array.
For example let's suppose that the small arrays are {1, 6, -2}, {3, 3} and {-5, 1}. And the indexes in the big array are {2, 3, 1, 3}. So the actual values in the big array after formatting it as concatenation of the small arrays will be {3, 3, -5, 1, 1, 6, -2, -5, 1}. In this example the maximum sum is 9.
Can you help Mostafa solve this problem?
Input
The first line contains two integers n and m, n is the number of the small arrays (1 ≤ n ≤ 50), and m is the number of indexes in the big array (1 ≤ m ≤ 250000). Then follow n lines, the i-th line starts with one integer l which is the size of the i-th array (1 ≤ l ≤ 5000), followed by l integers each one will be greater than or equal -1000 and less than or equal 1000. The last line contains m integers which are the indexes in the big array, and you should concatenate the small arrays in the same order, and each index will be greater than or equal to 1 and less than or equal to n.
The small arrays are numbered from 1 to n in the same order as given in the input. Some of the given small arrays may not be used in big array.
Note, that the array is very big. So if you try to build it straightforwardly, you will probably get time or/and memory limit exceeded.
Output
Print one line containing the maximum sum in the big array after formatting it as described above. You must choose at least one element for the sum, i. e. it cannot be empty.
Please, do not use %lld specificator to write 64-bit integers in C++. It is preferred to use cout (also you may use %I64d).
Examples
Input
3 4
3 1 6 -2
2 3 3
2 -5 1
2 3 1 3
Output
9
Input
6 1
4 0 8 -3 -10
8 3 -2 -5 10 8 -9 -5 -4
1 0
1 -3
3 -8 5 6
2 9 6
1
Output
8
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m;
int as[50][5000];
long long INF = 1LL << 62;
long long ls[59];
long long ds[52][4];
std::vector<int> ms;
void init() {
for (int i = (0); i < (n); ++i) {
for (int j = (0); j < (ls[i]); ++j) {
ds[i][1] += as[i][j];
}
long long tmp = 0;
for (int j = (0); j < (ls[i]); ++j) {
tmp += as[i][j];
ds[i][0] = max(ds[i][0], tmp);
}
tmp = 0;
for (int j = ls[i] - 1; j >= 0; j--) {
tmp += as[i][j];
ds[i][2] = max(ds[i][2], tmp);
}
long long cont = 0;
for (int j = (0); j < (ls[i]); ++j) {
cont = max(0LL, cont + as[i][j]);
ds[i][3] = max(ds[i][3], cont);
}
}
}
long long solve() {
long long ans = 0, cont = 0;
init();
for (int i = (0); i < (int((ms).size())); ++i) {
int idx = ms[i];
ans = max(ans, cont + ds[idx][0]);
ans = max(ans, ds[idx][3]);
cont = max(0LL, cont + ds[idx][1]);
cont = max(cont, ds[idx][2]);
}
if (ans == 0) {
sort((ms).begin(), (ms).end());
ms.erase(unique((ms).begin(), (ms).end()), ms.end());
ans = -INF;
for (int i = (0); i < (int((ms).size())); ++i) {
int id = ms[i];
for (int j = (0); j < (ls[id]); ++j) {
ans = max(ans, (long long)as[id][j]);
}
}
return ans;
}
return ans;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = (0); i < (n); ++i) {
int l;
scanf("%d", &l);
ls[i] = l;
for (int j = (0); j < (l); ++j) scanf("%d", as[i] + j);
}
for (int i = (0); i < (m); ++i) {
int x;
scanf("%d", &x);
ms.push_back(x - 1);
}
cout << solve() << endl;
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
This is the easy version of the problem. The difference is the constraint on the sum of lengths of strings and the number of test cases. You can make hacks only if you solve all versions of this task.
You are given a string s, consisting of lowercase English letters. Find the longest string, t, which satisfies the following conditions:
* The length of t does not exceed the length of s.
* t is a palindrome.
* There exists two strings a and b (possibly empty), such that t = a + b ( "+" represents concatenation), and a is prefix of s while b is suffix of s.
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 1000), the number of test cases. The next t lines each describe a test case.
Each test case is a non-empty string s, consisting of lowercase English letters.
It is guaranteed that the sum of lengths of strings over all test cases does not exceed 5000.
Output
For each test case, print the longest string which satisfies the conditions described above. If there exists multiple possible solutions, print any of them.
Example
Input
5
a
abcdfdcecba
abbaxyzyx
codeforces
acbba
Output
a
abcdfdcba
xyzyx
c
abba
Note
In the first test, the string s = "a" satisfies all conditions.
In the second test, the string "abcdfdcba" satisfies all conditions, because:
* Its length is 9, which does not exceed the length of the string s, which equals 11.
* It is a palindrome.
* "abcdfdcba" = "abcdfdc" + "ba", and "abcdfdc" is a prefix of s while "ba" is a suffix of s.
It can be proven that there does not exist a longer string which satisfies the conditions.
In the fourth test, the string "c" is correct, because "c" = "c" + "" and a or b can be empty. The other possible solution for this test is "s".
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int pref[2000005] = {};
string solve(const string& s) {
int c = 0;
string a = s;
reverse(a.begin(), a.end());
a = s + "#" + a;
c = 0;
for (int i = 1; i < (int)a.size(); i++) {
while (c != 0 && a[c] != a[i]) c = pref[c - 1];
if (a[c] == a[i]) c++;
pref[i] = c;
}
return s.substr(0, c);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
int T;
cin >> T;
while (T--) {
string s;
cin >> s;
int len = 1;
int n = int(s.size());
string ans = "";
int idx = -1;
int idx1 = n;
for (int i = 0, j = n - 1; i < j; i++, j--) {
if (s[i] == s[j]) {
idx = i;
idx1 = j;
} else {
break;
}
}
for (int i = 0; i <= idx; i++) {
ans.push_back(s[i]);
}
string xyz = ans;
string t = "";
for (int i = max(0, idx + 1); i < idx1; i++) {
t.push_back(s[i]);
}
string len1 = solve(t);
string tcopy = t;
reverse(tcopy.begin(), tcopy.end());
string len2 = solve(tcopy);
if (int(len1.size()) > int(len2.size())) {
ans += len1;
} else {
ans += len2;
}
reverse(xyz.begin(), xyz.end());
ans += xyz;
cout << ans << '\n';
}
return 0;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
A bus moves along the coordinate line Ox from the point x = 0 to the point x = a. After starting from the point x = 0, it reaches the point x = a, immediately turns back and then moves to the point x = 0. After returning to the point x = 0 it immediately goes back to the point x = a and so on. Thus, the bus moves from x = 0 to x = a and back. Moving from the point x = 0 to x = a or from the point x = a to x = 0 is called a bus journey. In total, the bus must make k journeys.
The petrol tank of the bus can hold b liters of gasoline. To pass a single unit of distance the bus needs to spend exactly one liter of gasoline. The bus starts its first journey with a full petrol tank.
There is a gas station in point x = f. This point is between points x = 0 and x = a. There are no other gas stations on the bus route. While passing by a gas station in either direction the bus can stop and completely refuel its tank. Thus, after stopping to refuel the tank will contain b liters of gasoline.
What is the minimum number of times the bus needs to refuel at the point x = f to make k journeys? The first journey starts in the point x = 0.
Input
The first line contains four integers a, b, f, k (0 < f < a ≤ 106, 1 ≤ b ≤ 109, 1 ≤ k ≤ 104) — the endpoint of the first bus journey, the capacity of the fuel tank of the bus, the point where the gas station is located, and the required number of journeys.
Output
Print the minimum number of times the bus needs to refuel to make k journeys. If it is impossible for the bus to make k journeys, print -1.
Examples
Input
6 9 2 4
Output
4
Input
6 10 2 4
Output
2
Input
6 5 4 3
Output
-1
Note
In the first example the bus needs to refuel during each journey.
In the second example the bus can pass 10 units of distance without refueling. So the bus makes the whole first journey, passes 4 units of the distance of the second journey and arrives at the point with the gas station. Then it can refuel its tank, finish the second journey and pass 2 units of distance from the third journey. In this case, it will again arrive at the point with the gas station. Further, he can refill the tank up to 10 liters to finish the third journey and ride all the way of the fourth journey. At the end of the journey the tank will be empty.
In the third example the bus can not make all 3 journeys because if it refuels during the second journey, the tanks will contain only 5 liters of gasoline, but the bus needs to pass 8 units of distance until next refueling.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, f, k, cur;
cin >> a >> b >> f >> k;
cur = b;
int ans = 0;
for (int i = 1; i < k; i++) {
if (i % 2) {
cur = cur - f;
if (0 > cur) {
cout << -1;
return 0;
}
if (2 * (a - f) > cur) {
cur = b;
ans++;
}
cur = cur - (a - f);
if (0 > cur) {
cout << -1;
return 0;
}
} else {
cur = cur - (a - f);
if (0 > cur) {
cout << -1;
return 0;
}
if (2 * f > cur) {
cur = b;
ans++;
}
cur = cur - f;
if (0 > cur) {
cout << -1;
return 0;
}
}
}
if (k % 2) {
cur = cur - f;
if (cur < 0) {
cout << -1;
return 0;
}
if ((a - f) > cur) {
cur = b;
ans++;
}
cur = cur - (a - f);
if (cur < 0) {
cout << -1;
return 0;
}
} else {
cur = cur - (a - f);
if (cur < 0) {
cout << -1;
return 0;
}
if (f > cur) {
cur = b;
ans++;
}
cur = cur - f;
if (cur < 0) {
cout << -1;
return 0;
}
}
cout << ans;
cin >> a;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
The country has n cities and n - 1 bidirectional roads, it is possible to get from every city to any other one if you move only along the roads. The cities are numbered with integers from 1 to n inclusive.
All the roads are initially bad, but the government wants to improve the state of some roads. We will assume that the citizens are happy about road improvement if the path from the capital located in city x to any other city contains at most one bad road.
Your task is — for every possible x determine the number of ways of improving the quality of some roads in order to meet the citizens' condition. As those values can be rather large, you need to print each value modulo 1 000 000 007 (109 + 7).
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 2·105) — the number of cities in the country. Next line contains n - 1 positive integers p2, p3, p4, ..., pn (1 ≤ pi ≤ i - 1) — the description of the roads in the country. Number pi means that the country has a road connecting city pi and city i.
Output
Print n integers a1, a2, ..., an, where ai is the sought number of ways to improve the quality of the roads modulo 1 000 000 007 (109 + 7), if the capital of the country is at city number i.
Examples
Input
3
1 1
Output
4 3 3
Input
5
1 2 3 4
Output
5 8 9 8 5
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<int> E[201000];
int n;
long long Mod = 1000000007, D[201000], DP[201000];
void DFS(int a) {
int i;
long long t = 1;
for (i = 0; i < E[a].size(); i++) {
DFS(E[a][i]);
t = t * (D[E[a][i]] + 1) % Mod;
}
D[a] = t;
}
long long D1[201000];
void Do(int a) {
int i;
long long t = 1;
if (a == 1) DP[a] = 1;
D1[0] = 1;
for (i = 0; i < E[a].size(); i++) {
D1[i + 1] = D1[i] * (D[E[a][i]] + 1) % Mod;
}
for (i = E[a].size() - 1; i >= 0; i--) {
DP[E[a][i]] = (t * D1[i] % Mod * DP[a] + 1) % Mod;
t = t * (D[E[a][i]] + 1) % Mod;
}
for (i = 0; i < E[a].size(); i++) Do(E[a][i]);
}
int main() {
int i, a;
scanf("%d", &n);
for (i = 2; i <= n; i++) {
scanf("%d", &a);
E[a].push_back(i);
}
DFS(1);
Do(1);
for (i = 1; i <= n; i++) printf("%d ", DP[i] * D[i] % Mod);
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
Toad Pimple has an array of integers a_1, a_2, …, a_n.
We say that y is reachable from x if x<y and there exists an integer array p such that x = p_1 < p_2 < … < p_k=y, and a_{p_i} \& a_{p_{i+1}} > 0 for all integers i such that 1 ≤ i < k.
Here \& denotes the [bitwise AND operation](https://en.wikipedia.org/wiki/Bitwise_operation#AND).
You are given q pairs of indices, check reachability for each of them.
Input
The first line contains two integers n and q (2 ≤ n ≤ 300 000, 1 ≤ q ≤ 300 000) — the number of integers in the array and the number of queries you need to answer.
The second line contains n space-separated integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 300 000) — the given array.
The next q lines contain two integers each. The i-th of them contains two space-separated integers x_i and y_i (1 ≤ x_i < y_i ≤ n). You need to check if y_i is reachable from x_i.
Output
Output q lines. In the i-th of them print "Shi" if y_i is reachable from x_i, otherwise, print "Fou".
Example
Input
5 3
1 3 0 2 1
1 3
2 4
1 4
Output
Fou
Shi
Shi
Note
In the first example, a_3 = 0. You can't reach it, because AND with it is always zero. a_2 \& a_4 > 0, so 4 is reachable from 2, and to go from 1 to 4 you can use p = [1, 2, 4].
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int MBITS = 19;
bool answer_query(vector<int>& a, vector<vector<int> >& dp, int x, int y) {
for (int i = 0; i < MBITS; i++) {
if ((a[x] & (1 << i)) > 0) {
if (x <= dp[i][y]) return true;
}
}
return false;
}
int main() {
int n, q;
cin >> n >> q;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
vector<vector<int> > bits(MBITS);
vector<int> dprow(n, -1);
vector<vector<int> > dp(MBITS, dprow);
for (int i = 0; i < n; i++) {
for (int j = 0; j < MBITS; j++) {
if ((a[i] & (1 << j)) > 0) {
int sj = bits[j].size();
if (sj > 0) {
int pj = bits[j][sj - 1];
dp[j][i] = max(dp[j][i], pj);
for (int k = 0; k < MBITS; k++) {
dp[k][i] = max(dp[k][pj], dp[k][i]);
}
}
bits[j].push_back(i);
}
}
}
for (int i = 0; i < q; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
if (answer_query(a, dp, x, y))
cout << "Shi" << endl;
else
cout << "Fou" << endl;
}
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
Ilya is a very clever lion, he lives in an unusual city ZooVille. In this city all the animals have their rights and obligations. Moreover, they even have their own bank accounts. The state of a bank account is an integer. The state of a bank account can be a negative number. This means that the owner of the account owes the bank money.
Ilya the Lion has recently had a birthday, so he got a lot of gifts. One of them (the gift of the main ZooVille bank) is the opportunity to delete the last digit or the digit before last from the state of his bank account no more than once. For example, if the state of Ilya's bank account is -123, then Ilya can delete the last digit and get his account balance equal to -12, also he can remove its digit before last and get the account balance equal to -13. Of course, Ilya is permitted not to use the opportunity to delete a digit from the balance.
Ilya is not very good at math, and that's why he asks you to help him maximize his bank account. Find the maximum state of the bank account that can be obtained using the bank's gift.
Input
The single line contains integer n (10 ≤ |n| ≤ 109) — the state of Ilya's bank account.
Output
In a single line print an integer — the maximum state of the bank account that Ilya can get.
Examples
Input
2230
Output
2230
Input
-10
Output
0
Input
-100003
Output
-10000
Note
In the first test sample Ilya doesn't profit from using the present.
In the second test sample you can delete digit 1 and get the state of the account equal to 0.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int scet;
cin >> scet;
if (scet >= 0) {
cout << scet;
return 0;
}
int scet10;
int scet11;
if (scet < 0) {
scet10 = scet / 10;
int lns = scet % 10;
scet11 = scet / 100;
scet11 *= 10;
scet11 += lns;
}
if (scet10 > scet11) {
scet11 = scet10;
}
cout << scet11;
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
A boy named Ayrat lives on planet AMI-1511. Each inhabitant of this planet has a talent. Specifically, Ayrat loves running, moreover, just running is not enough for him. He is dreaming of making running a real art.
First, he wants to construct the running track with coating t. On planet AMI-1511 the coating of the track is the sequence of colored blocks, where each block is denoted as the small English letter. Therefore, every coating can be treated as a string.
Unfortunately, blocks aren't freely sold to non-business customers, but Ayrat found an infinite number of coatings s. Also, he has scissors and glue. Ayrat is going to buy some coatings s, then cut out from each of them exactly one continuous piece (substring) and glue it to the end of his track coating. Moreover, he may choose to flip this block before glueing it. Ayrat want's to know the minimum number of coating s he needs to buy in order to get the coating t for his running track. Of course, he also want's to know some way to achieve the answer.
Input
First line of the input contains the string s — the coating that is present in the shop. Second line contains the string t — the coating Ayrat wants to obtain. Both strings are non-empty, consist of only small English letters and their length doesn't exceed 2100.
Output
The first line should contain the minimum needed number of coatings n or -1 if it's impossible to create the desired coating.
If the answer is not -1, then the following n lines should contain two integers xi and yi — numbers of ending blocks in the corresponding piece. If xi ≤ yi then this piece is used in the regular order, and if xi > yi piece is used in the reversed order. Print the pieces in the order they should be glued to get the string t.
Examples
Input
abc
cbaabc
Output
2
3 1
1 3
Input
aaabrytaaa
ayrat
Output
3
1 1
6 5
8 7
Input
ami
no
Output
-1
Note
In the first sample string "cbaabc" = "cba" + "abc".
In the second sample: "ayrat" = "a" + "yr" + "at".
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, rs, t;
cin >> s >> t;
rs = s;
reverse(rs.begin(), rs.end());
s = rs + '#' + s;
int m = s.size(), n = t.size();
vector<vector<int> > lcp(n + 1, vector<int>(m + 1));
vector<int> ml(n);
for (int i = n - 1; i >= 0; --i)
for (int j = m - 1, mx = 0; j >= 0; --j) {
if (t[i] == s[j]) lcp[i][j] = lcp[i + 1][j + 1] + 1;
if ((lcp[i][j] >= mx && j > m / 2) || lcp[i][j] > mx)
mx = lcp[i][j], ml[i] = j;
}
vector<pair<int, int> > res;
int k = 0, d = m / 2;
while (k < n) {
if (lcp[k][ml[k]] == 0) {
cout << -1;
return 0;
}
if (ml[k] > d)
res.push_back(make_pair(ml[k] - d, ml[k] - d - 1 + lcp[k][ml[k]]));
else
res.push_back(make_pair(d - ml[k], d + 1 - (ml[k] + lcp[k][ml[k]])));
k += lcp[k][ml[k]];
}
cout << res.size() << endl;
for (auto c : res) cout << c.first << " " << c.second << endl;
}
``` |
### Prompt
Please create a solution in Cpp 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;
int ans1 = 1, ans2 = 0, n, x[26], now;
char s[100100];
int main() {
scanf("%s", s);
n = strlen(s) - 1;
for (int i = 0; i <= 25; ++i) x[i] = -1;
for (int i = 0; i <= n; ++i) {
if (s[i] == '?')
if (i)
++ans2;
else
ans1 *= 9;
if (s[i] >= 'A' && s[i] <= 'Z' && (x[s[i] - 'A'] < 0)) x[s[i] - 'A'] = i;
}
sort(x, x + 26);
now = 10;
for (int i = 0; i <= 25; ++i)
if (x[i] >= 0)
if (x[i] == 0)
ans1 *= 9, --now;
else
ans1 *= now, --now;
printf("%d", ans1);
for (int i = 1; i <= ans2; ++i) printf("0");
puts("");
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
Wu got hungry after an intense training session, and came to a nearby store to buy his favourite instant noodles. After Wu paid for his purchase, the cashier gave him an interesting task.
You are given a bipartite graph with positive integers in all vertices of the right half. For a subset S of vertices of the left half we define N(S) as the set of all vertices of the right half adjacent to at least one vertex in S, and f(S) as the sum of all numbers in vertices of N(S). Find the greatest common divisor of f(S) for all possible non-empty subsets S (assume that GCD of empty set is 0).
Wu is too tired after his training to solve this problem. Help him!
Input
The first line contains a single integer t (1 ≤ t ≤ 500 000) — the number of test cases in the given test set. Test case descriptions follow.
The first line of each case description contains two integers n and m (1~≤~n,~m~≤~500 000) — the number of vertices in either half of the graph, and the number of edges respectively.
The second line contains n integers c_i (1 ≤ c_i ≤ 10^{12}). The i-th number describes the integer in the vertex i of the right half of the graph.
Each of the following m lines contains a pair of integers u_i and v_i (1 ≤ u_i, v_i ≤ n), describing an edge between the vertex u_i of the left half and the vertex v_i of the right half. It is guaranteed that the graph does not contain multiple edges.
Test case descriptions are separated with empty lines. The total value of n across all test cases does not exceed 500 000, and the total value of m across all test cases does not exceed 500 000 as well.
Output
For each test case print a single integer — the required greatest common divisor.
Example
Input
3
2 4
1 1
1 1
1 2
2 1
2 2
3 4
1 1 1
1 1
1 2
2 2
2 3
4 7
36 31 96 29
1 2
1 3
1 4
2 2
2 4
3 1
4 3
Output
2
1
12
Note
The greatest common divisor of a set of integers is the largest integer g such that all elements of the set are divisible by g.
In the first sample case vertices of the left half and vertices of the right half are pairwise connected, and f(S) for any non-empty subset is 2, thus the greatest common divisor of these values if also equal to 2.
In the second sample case the subset \{1\} in the left half is connected to vertices \{1, 2\} of the right half, with the sum of numbers equal to 2, and the subset \{1, 2\} in the left half is connected to vertices \{1, 2, 3\} of the right half, with the sum of numbers equal to 3. Thus, f(\{1\}) = 2, f(\{1, 2\}) = 3, which means that the greatest common divisor of all values of f(S) is 1.
### Response
```cpp
#include <bits/stdc++.h>
#pragma GCC optimize(3)
#pragma GCC optimize(2)
using namespace std;
const int maxn = 5e5 + 10;
int N, M;
long long c[maxn];
vector<int> g[maxn];
long long gcd(long long a, long long b) { return a == 0 ? b : gcd(b % a, a); }
int main() {
int t;
scanf("%d", &t);
while (t--) {
scanf("%d %d", &N, &M);
for (int i = 1; i <= N; ++i) scanf("%lld", &c[i]), g[i].clear();
for (int i = 1; i <= M; ++i) {
int x, y;
scanf("%d %d", &x, &y);
g[y].push_back(x);
}
map<set<int>, long long> mp;
for (int i = 1; i <= N; ++i) {
set<int> vis;
if (g[i].empty()) continue;
for (int j : g[i]) {
vis.insert(j);
}
if (!g[i].empty()) {
if (mp.find(vis) == mp.end()) {
mp[vis] = 0;
}
mp[vis] += c[i];
}
}
long long ans = 0;
for (auto& it : mp) {
ans = gcd(ans, it.second);
}
printf("%lld\n", ans);
}
}
``` |
Subsets and Splits