text
stringlengths 424
69.5k
|
|---|
### Prompt
Create a solution in Cpp for the following problem:
In 2N - 1 boxes there are apples and oranges. Your task is to choose N boxes so, that they will contain not less than half of all the apples and not less than half of all the oranges.
Input
The first input line contains one number T — amount of tests. The description of each test starts with a natural number N — amount of boxes. Each of the following 2N - 1 lines contains numbers ai and oi — amount of apples and oranges in the i-th box (0 ≤ ai, oi ≤ 109). The sum of N in all the tests in the input doesn't exceed 105. All the input numbers are integer.
Output
For each test output two lines. In the first line output YES, if it's possible to choose N boxes, or NO otherwise. If the answer is positive output in the second line N numbers — indexes of the chosen boxes. Boxes are numbered from 1 in the input order. Otherwise leave the second line empty. Separate the numbers with one space.
Examples
Input
2
2
10 15
5 7
20 18
1
0 0
Output
YES
1 3
YES
1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast,no-stack-protector")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << "\n";
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " , ";
__f(comma + 1, args...);
}
const int N = 1e5 + 5;
const int inf = 1e9;
const long long INF = 1e18;
std::mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
struct data {
long long int a, o, id;
data() : a(0), o(0), id(0) {}
data(long long int a, long long int o, long long int id)
: a(a), o(o), id(0) {}
} A[2 * N];
int main(int argc, char const* argv[]) {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
srand(time(0));
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
long long int x = 0, y = 0;
for (int i = 1; i <= 2 * n - 1; i++) {
cin >> A[i].a >> A[i].o;
A[i].id = i;
x += A[i].a, y += A[i].o;
}
bool f = false;
for (int i = 1; i <= 700; i++) {
shuffle(A + 1, A + 2 * n, rng);
long long int cx = 0, cy = 0;
vector<int> V;
for (int j = 1; j <= n; j++) {
cx += A[j].a, cy += A[j].o;
V.push_back(A[j].id);
}
if (2 * cx >= x && 2 * cy >= y) {
cout << "YES"
<< "\n";
sort(V.begin(), V.end());
for (auto it : V) cout << it << " ";
cout << "\n";
f = true;
break;
}
}
if (!f)
cout << "NO"
<< "\n";
}
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
In the Main Berland Bank n people stand in a queue at the cashier, everyone knows his/her height hi, and the heights of the other people in the queue. Each of them keeps in mind number ai — how many people who are taller than him/her and stand in queue in front of him.
After a while the cashier has a lunch break and the people in the queue seat on the chairs in the waiting room in a random order.
When the lunch break was over, it turned out that nobody can remember the exact order of the people in the queue, but everyone remembers his number ai.
Your task is to restore the order in which the people stood in the queue if it is possible. There may be several acceptable orders, but you need to find any of them. Also, you need to print a possible set of numbers hi — the heights of people in the queue, so that the numbers ai are correct.
Input
The first input line contains integer n — the number of people in the queue (1 ≤ n ≤ 3000). Then n lines contain descriptions of the people as "namei ai" (one description on one line), where namei is a non-empty string consisting of lowercase Latin letters whose length does not exceed 10 characters (the i-th person's name), ai is an integer (0 ≤ ai ≤ n - 1), that represents the number of people who are higher and stand in the queue in front of person i. It is guaranteed that all names are different.
Output
If there's no acceptable order of the people in the queue, print the single line containing "-1" without the quotes. Otherwise, print in n lines the people as "namei hi", where hi is the integer from 1 to 109 (inclusive), the possible height of a man whose name is namei. Print the people in the order in which they stand in the queue, starting from the head of the queue and moving to its tail. Numbers hi are not necessarily unique.
Examples
Input
4
a 0
b 2
c 0
d 0
Output
a 150
c 170
d 180
b 160
Input
4
vasya 0
petya 1
manya 3
dunay 3
Output
-1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long double PI = 3.141592653589793;
const int mod = 1e9 + 7;
int CASE = 1;
const int mxn = 1e3;
const long long infll = 1e18;
const int infi = 1e9;
bool prime(long long n) {
if (n <= 1) return false;
if (n == 2 or n == 3) return true;
if (n % 2 == 0 or n % 3 == 0) return false;
for (long long i = 5; i * i <= n; i += 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
long long __gcd(long long a, long long b) { return !b ? a : __gcd(b, a % b); }
long long power(long long a, long long b, long long MOD) {
long long x = a, res = 1, p = b;
while (p > 0) {
if (p & 1) res *= x;
x *= x;
p >>= 1;
x %= MOD, res %= MOD;
}
return res;
}
void solve() {
int n;
cin >> n;
vector<pair<string, int>> v(n);
for (long long i = 0; i < n; i++) cin >> v[i].first >> v[i].second;
sort(v.begin(), v.end(), [](pair<string, int> a, pair<string, int> b) {
return a.second < b.second;
});
for (long long i = 0; i < n; i++) {
if (v[i].second > i) {
cout << -1;
return;
}
}
vector<pair<string, int>> ans;
for (long long i = 0; i < n; i++) {
pair<string, int> p = make_pair(v[i].first, 100000 - i);
ans.insert(ans.begin() + v[i].second, p);
}
for (auto x : ans) cout << x.first << ' ' << x.second << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int T = 1;
while (T--) {
solve();
}
return 0;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
Input Format
N K
a_1 a_2 a_3 ... a_N
Output Format
Print the minimum cost in one line. In the end put a line break.
Constraints
* 1 ≤ K ≤ N ≤ 15
* 1 ≤ a_i ≤ 10^9
Scoring
Subtask 1 [120 points]
* N = K
Subtask 2 [90 points]
* N ≤ 5
* a_i ≤ 7
Subtask 3 [140 points]
* There are no additional constraints.
Output Format
Print the minimum cost in one line. In the end put a line break.
Constraints
* 1 ≤ K ≤ N ≤ 15
* 1 ≤ a_i ≤ 10^9
Scoring
Subtask 1 [120 points]
* N = K
Subtask 2 [90 points]
* N ≤ 5
* a_i ≤ 7
Subtask 3 [140 points]
* There are no additional constraints.
Input Format
N K
a_1 a_2 a_3 ... a_N
Example
Input
5 5
3949 3774 3598 3469 3424
Output
1541
### Response
```cpp
#include <bits/stdc++.h>
#define rep(i, n) for(int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
const ll INF = 1LL << 60;
int main() {
int n, k;
cin >> n >> k;
vector<ll> a(n);
rep(i, n) cin >> a[i];
ll ans = INF;
rep(bit, (1 << n)) {
vector<int> s;
rep(i, n) {
if (bit & (1 << i)) {
s.push_back(i);
}
}
if (s.size() < k) continue;
vector<ll> t(n);
rep(i, s.size()) {
int u = s[i];
rep(j, u) {
if (a[j] + t[j] >= a[u] + t[u]) {
t[u] = a[j] + t[j] - a[u] + 1;
}
}
}
ll mn = 0;
rep(i, n) mn += t[i];
ans = min(ans, mn);
}
cout << ans << endl;
return 0;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
You are given a tree (connected graph without cycles) consisting of n vertices. The tree is unrooted — it is just a connected undirected graph without cycles.
In one move, you can choose exactly k leaves (leaf is such a vertex that is connected to only one another vertex) connected to the same vertex and remove them with edges incident to them. I.e. you choose such leaves u_1, u_2, ..., u_k that there are edges (u_1, v), (u_2, v), ..., (u_k, v) and remove these leaves and these edges.
Your task is to find the maximum number of moves you can perform if you remove leaves optimally.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 2 ⋅ 10^4) — the number of test cases. Then t test cases follow.
The first line of the test case contains two integers n and k (2 ≤ n ≤ 2 ⋅ 10^5; 1 ≤ k < n) — the number of vertices in the tree and the number of leaves you remove in one move, respectively. The next n-1 lines describe edges. The i-th edge is represented as two integers x_i and y_i (1 ≤ x_i, y_i ≤ n), where x_i and y_i are vertices the i-th edge connects. It is guaranteed that the given set of edges forms a tree.
It is guaranteed that the sum of n does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the maximum number of moves you can perform if you remove leaves optimally.
Example
Input
4
8 3
1 2
1 5
7 6
6 8
3 1
6 4
6 1
10 3
1 2
1 10
2 3
1 5
1 6
2 4
7 10
10 9
8 10
7 2
3 1
4 5
3 6
7 4
1 2
1 4
5 1
1 2
2 3
4 3
5 3
Output
2
3
3
4
Note
The picture corresponding to the first test case of the example:
<image>
There you can remove vertices 2, 5 and 3 during the first move and vertices 1, 7 and 4 during the second move.
The picture corresponding to the second test case of the example:
<image>
There you can remove vertices 7, 8 and 9 during the first move, then vertices 5, 6 and 10 during the second move and vertices 1, 3 and 4 during the third move.
The picture corresponding to the third test case of the example:
<image>
There you can remove vertices 5 and 7 during the first move, then vertices 2 and 4 during the second move and vertices 1 and 6 during the third move.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, k, ans;
vector<set<int>> g;
vector<set<int>> leaves;
struct comp {
bool operator()(int a, int b) const {
if (leaves[a].size() == leaves[b].size()) return a < b;
return leaves[a].size() > leaves[b].size();
}
};
int main() {
int t;
cin >> t;
while (t--) {
cin >> n >> k;
g = leaves = vector<set<int>>(n);
for (int i = 0; i < n - 1; ++i) {
int x, y;
cin >> x >> y;
--x, --y;
g[x].insert(y);
g[y].insert(x);
}
for (int i = 0; i < n; ++i) {
if (g[i].size() == 1) {
leaves[*g[i].begin()].insert(i);
}
}
set<int, comp> st;
for (int i = 0; i < n; ++i) {
st.insert(i);
}
int ans = 0;
while (true) {
int v = *st.begin();
if (int(leaves[v].size()) < k) break;
for (int i = 0; i < k; ++i) {
int leaf = *leaves[v].begin();
g[leaf].erase(v);
g[v].erase(leaf);
st.erase(v);
st.erase(leaf);
leaves[v].erase(leaf);
if (leaves[leaf].count(v)) leaves[leaf].erase(v);
if (g[v].size() == 1) {
int to = *g[v].begin();
st.erase(to);
leaves[to].insert(v);
st.insert(to);
}
st.insert(v);
st.insert(leaf);
}
ans += 1;
}
cout << ans << endl;
}
return 0;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
N problems have been chosen by the judges, now it's time to assign scores to them!
Problem i must get an integer score A_i between 1 and N, inclusive. The problems have already been sorted by difficulty: A_1 \le A_2 \le \ldots \le A_N must hold. Different problems can have the same score, though.
Being an ICPC fan, you want contestants who solve more problems to be ranked higher. That's why, for any k (1 \le k \le N-1), you want the sum of scores of any k problems to be strictly less than the sum of scores of any k+1 problems.
How many ways to assign scores do you have? Find this number modulo the given prime M.
Constraints
* 2 \leq N \leq 5000
* 9 \times 10^8 < M < 10^9
* M is a prime.
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N M
Output
Print the number of ways to assign scores to the problems, modulo M.
Examples
Input
2 998244353
Output
3
Input
3 998244353
Output
7
Input
6 966666661
Output
66
Input
96 925309799
Output
83779
### Response
```cpp
#include<iostream>
#include<cstdio>
#define ll long long
using namespace std;
ll ans=0,f[1000010];
int n,mod,c[1000010];
int main(){
scanf("%d%d",&n,&mod);
if(n&1){
for(register int i=2,j=0;j<n/2;i++,j++)c[i]=j;
for(register int i=n,j=1;j<=n/2;i--,j++)c[i]=j;
}
else{
for(register int i=2,j=0;j<=(n-1)/2;i++,j++)c[i]=j;
for(register int i=n,j=1;j<=(n-1)/2;i--,j++)c[i]=j;
}
f[0]=1;
for(register int i=2;i<=n;i++){
c[i]++;
for(register int j=c[i];j<n;j++){
f[j]=(f[j]+f[j-c[i]])%mod;
}
}
//for(register int i=0;i<n;i++)cout<<"f["<<i<<"]="<<f[i]<<endl;
for(register int i=0;i<n;i++)ans=(ans+f[i]*(n-i))%mod;
printf("%lld",ans);
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
In the Isle of Guernsey there are n different types of coins. For each i (1 ≤ i ≤ n), coin of type i is worth ai cents. It is possible that ai = aj for some i and j (i ≠ j).
Bessie has some set of these coins totaling t cents. She tells Jessie q pairs of integers. For each i (1 ≤ i ≤ q), the pair bi, ci tells Jessie that Bessie has a strictly greater number of coins of type bi than coins of type ci. It is known that all bi are distinct and all ci are distinct.
Help Jessie find the number of possible combinations of coins Bessie could have. Two combinations are considered different if there is some i (1 ≤ i ≤ n), such that the number of coins Bessie has of type i is different in the two combinations. Since the answer can be very large, output it modulo 1000000007 (109 + 7).
If there are no possible combinations of coins totaling t cents that satisfy Bessie's conditions, output 0.
Input
The first line contains three space-separated integers, n, q and t (1 ≤ n ≤ 300; 0 ≤ q ≤ n; 1 ≤ t ≤ 105). The second line contains n space separated integers, a1, a2, ..., an (1 ≤ ai ≤ 105). The next q lines each contain two distinct space-separated integers, bi and ci (1 ≤ bi, ci ≤ n; bi ≠ ci).
It's guaranteed that all bi are distinct and all ci are distinct.
Output
A single integer, the number of valid coin combinations that Bessie could have, modulo 1000000007 (109 + 7).
Examples
Input
4 2 17
3 1 2 5
4 2
3 4
Output
3
Input
3 2 6
3 1 1
1 2
2 3
Output
0
Input
3 2 10
1 2 3
1 2
2 1
Output
0
Note
For the first sample, the following 3 combinations give a total of 17 cents and satisfy the given conditions: {0 of type 1, 1 of type 2, 3 of type 3, 2 of type 4}, {0, 0, 6, 1}, {2, 0, 3, 1}.
No other combinations exist. Note that even though 4 occurs in both bi and ci, the problem conditions are still satisfied because all bi are distinct and all ci are distinct.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
inline int max(int a, int b) { return a > b ? a : b; }
inline int min(int a, int b) { return a < b ? a : b; }
inline int gcd(int a, int b) {
if (a % b)
return gcd(b, a % b);
else
return b;
}
inline int lcm(int a, int b) { return (a * (b / gcd(a, b))); }
inline int And(int mask, int bit) { return mask & (1 << bit); }
inline int Or(int mask, int bit) { return mask | (1 << bit); }
inline int Xor(int mask, int bit) { return mask & (~(1 << bit)); }
int a[333], deg[333], mark[333];
int n, q, u, v, x, y;
bool circle;
vector<int> adj[333], topo;
long long dp[333][100111], w[333], t;
void dfs(int u) {
if (mark[u]) return;
mark[u] = 1;
w[u] = a[u];
for (int i = 0; i < adj[u].size(); i++) {
dfs(adj[u][i]);
w[u] += w[adj[u][i]];
}
topo.push_back(w[u]);
}
int main() {
scanf("%d %d %I64d", &n, &q, &t);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
deg[i] = mark[i] = 0;
}
for (int i = 1; i <= q; i++) {
scanf("%d %d", &u, &v);
adj[v].push_back(u);
deg[u]++;
}
circle = false;
for (int i = 1; i <= n; i++)
if (deg[i] == 0) {
x = topo.size();
dfs(i);
y = topo.size();
for (int i = x; i < y - 1; i++) t -= topo[i];
if (t < 0) {
circle = true;
break;
}
}
for (int i = 1; i <= n; i++)
if (mark[i] == 0) {
circle = true;
break;
}
if (circle)
puts("0");
else {
dp[0][0] = 1;
for (int i = 1; i <= n; i++)
for (int j = 0; j <= t; j++) {
dp[i][j] = dp[i - 1][j];
if (j >= topo[i - 1]) dp[i][j] += dp[i][j - topo[i - 1]];
dp[i][j] %= 1000000007;
}
printf("%I64d\n", dp[n][t]);
}
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
Takahashi has N days of summer vacation.
His teacher gave him M summer assignments. It will take A_i days for him to do the i-th assignment.
He cannot do multiple assignments on the same day, or hang out on a day he does an assignment.
What is the maximum number of days Takahashi can hang out during the vacation if he finishes all the assignments during this vacation?
If Takahashi cannot finish all the assignments during the vacation, print `-1` instead.
Constraints
* 1 \leq N \leq 10^6
* 1 \leq M \leq 10^4
* 1 \leq A_i \leq 10^4
Input
Input is given from Standard Input in the following format:
N M
A_1 ... A_M
Output
Print the maximum number of days Takahashi can hang out during the vacation, or `-1`.
Examples
Input
41 2
5 6
Output
30
Input
10 2
5 6
Output
-1
Input
11 2
5 6
Output
0
Input
314 15
9 26 5 35 8 9 79 3 23 8 46 2 6 43 3
Output
9
### Response
```cpp
#include<iostream>
using namespace std;
int main(){
int n,m,x;
long int sum=0;
cin>>n>>m;
while(m--){
cin>>x;
sum+=x;
}
if(n>=sum) cout<<n-sum;
else cout<<-1;
return 0;}
``` |
### Prompt
Please create a solution in cpp to the following problem:
Little Artem has invented a time machine! He could go anywhere in time, but all his thoughts of course are with computer science. He wants to apply this time machine to a well-known data structure: multiset.
Artem wants to create a basic multiset of integers. He wants these structure to support operations of three types:
1. Add integer to the multiset. Note that the difference between set and multiset is that multiset may store several instances of one integer.
2. Remove integer from the multiset. Only one instance of this integer is removed. Artem doesn't want to handle any exceptions, so he assumes that every time remove operation is called, that integer is presented in the multiset.
3. Count the number of instances of the given integer that are stored in the multiset.
But what about time machine? Artem doesn't simply apply operations to the multiset one by one, he now travels to different moments of time and apply his operation there. Consider the following example.
* First Artem adds integer 5 to the multiset at the 1-st moment of time.
* Then Artem adds integer 3 to the multiset at the moment 5.
* Then Artem asks how many 5 are there in the multiset at moment 6. The answer is 1.
* Then Artem returns back in time and asks how many integers 3 are there in the set at moment 4. Since 3 was added only at moment 5, the number of integers 3 at moment 4 equals to 0.
* Then Artem goes back in time again and removes 5 from the multiset at moment 3.
* Finally Artyom asks at moment 7 how many integers 5 are there in the set. The result is 0, since we have removed 5 at the moment 3.
Note that Artem dislikes exceptions so much that he assures that after each change he makes all delete operations are applied only to element that is present in the multiset. The answer to the query of the third type is computed at the moment Artem makes the corresponding query and are not affected in any way by future changes he makes.
Help Artem implement time travellers multiset.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100 000) — the number of Artem's queries.
Then follow n lines with queries descriptions. Each of them contains three integers ai, ti and xi (1 ≤ ai ≤ 3, 1 ≤ ti, xi ≤ 109) — type of the query, moment of time Artem travels to in order to execute this query and the value of the query itself, respectively. It's guaranteed that all moments of time are distinct and that after each operation is applied all operations of the first and second types are consistent.
Output
For each ask operation output the number of instances of integer being queried at the given moment of time.
Examples
Input
6
1 1 5
3 5 5
1 2 5
3 6 5
2 3 5
3 7 5
Output
1
2
1
Input
3
1 1 1
2 2 1
3 3 1
Output
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n;
map<int, map<int, int> > bit;
void u(int t, int x) {
while (t <= 1e9) {
bit[t][x]++;
t += (t & -t);
}
}
void d(int t, int x) {
while (t <= 1e9) {
bit[t][x]--;
t += t & -t;
}
}
void cnt(int t, int x) {
int ans = 0;
while (t > 0) {
ans += bit[t][x];
t -= t & -t;
}
cout << ans << endl;
}
void solve() {
cin >> n;
for (int i = 0; i < n; i++) {
int a, t, c;
cin >> a >> t >> c;
if (a == 1) {
u(t, c);
} else if (a == 2) {
d(t, c);
} else {
cnt(t, c);
}
}
}
int main() {
int t;
t = 1;
while (t--) {
solve();
}
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
You are given an array A of length N. Your task is to divide it into several contiguous subarrays. Here, all subarrays obtained must be sorted in either non-decreasing or non-increasing order. At least how many subarrays do you need to divide A into?
Constraints
* 1 \leq N \leq 10^5
* 1 \leq A_i \leq 10^9
* Each A_i is an integer.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
Output
Print the minimum possible number of subarrays after division of A.
Examples
Input
6
1 2 3 2 2 1
Output
2
Input
9
1 2 1 2 1 2 1 2 1
Output
5
Input
7
1 2 3 2 1 999999999 1000000000
Output
3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int A[N];
for (int i = 0; i < N; i++) {
cin >> A[i];
}
int ans = 0;
for (int i = 0; i < N; i++){
while (i+1 <= N && A[i] == A[i+1]) i++;
if (A[i] > A[i+1]) {
while (i+1 <= N && A[i] >= A[i+1]) i++;
} else {
while (i+1 <= N && A[i] <= A[i+1]) i++;
}
ans++;
}
cout << ans << endl;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
You've got string s, consisting of only lowercase English letters. Find its lexicographically maximum subsequence.
We'll call a non-empty string s[p1p2... pk] = sp1sp2... spk(1 ≤ p1 < p2 < ... < pk ≤ |s|) a subsequence of string s = s1s2... s|s|.
String x = x1x2... x|x| is lexicographically larger than string y = y1y2... y|y|, if either |x| > |y| and x1 = y1, x2 = y2, ... , x|y| = y|y|, or exists such number r (r < |x|, r < |y|), that x1 = y1, x2 = y2, ... , xr = yr and xr + 1 > yr + 1. Characters in lines are compared like their ASCII codes.
Input
The single line contains a non-empty string s, consisting only of lowercase English letters. The string's length doesn't exceed 105.
Output
Print the lexicographically maximum subsequence of string s.
Examples
Input
ababba
Output
bbba
Input
abbcbccacbbcbaaba
Output
cccccbba
Note
Let's look at samples and see what the sought subsequences look like (they are marked with uppercase bold letters).
The first sample: aBaBBA
The second sample: abbCbCCaCbbCBaaBA
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline string DISPLAYBIT(T n, int s, int e) {
string a;
while (s >= e) {
if (s < sizeof(n) * CHAR_BIT)
((sizeof(n) == 4) && (((n) & (1 << (s))) != 0)) ||
((sizeof(n) == 8) && (((n) & (((long long)(1)) << (s))) != 0))
? a += '1'
: a += '0';
s--;
}
return a;
}
template <class T>
inline int COUNTBIT(T n) {
return (sizeof(n) == 4) ? __builtin_popcount(n) : __builin_popcountl(n);
}
template <class T>
inline int LSB(T n) {
return (sizeof(n) == 4) ? __builtin_ffs(n) - 1 : __builtin_ffsl(n) - 1;
}
template <class T>
inline int MSB(T n) {
return (sizeof(n) == 4) ? 31 - __builtin_clz(n) : 63 - __builtin_clzl(n);
}
template <class T>
inline T GCD(T a, T b) {
if (a < 0) return GCD(-a, b);
if (b < 0) return GCD(a, -b);
return (b == 0) ? a : GCD(b, a % b);
}
template <class T>
inline T LCM(T a, T b) {
if (a < 0) return LCM(-a, b);
if (b < 0) return LCM(a, -b);
return a * (b / GCD(a, b));
}
template <class T>
inline T EUCLIDEAN(T a, T b, T& x, T& y) {
if (a < 0) {
T d = EUCLIDEAN(-a, b, x, y);
x = -x;
return d;
}
if (b < 0) {
T d = EUCLIDEAN(a, -b, x, y);
y = -y;
return d;
}
if (b == 0) {
x = 1;
y = 0;
return a;
} else {
T d = EUCLIDEAN(b, a % b, x, y);
T t = x;
x = y;
y = t - (a / b) * y;
return d;
}
}
template <class T>
inline vector<pair<T, int> > FACTORISE(T n) {
vector<pair<T, int> > R;
for (T i = 2; n > 1;) {
if (n % i == 0) {
int C = 0;
for (; n % i == 0; C++, n /= i)
;
R.push_back(make_pair(i, C));
}
i++;
if (i > n / i) i = n;
}
if (n > 1) R.push_back(make_pair(n, 1));
return R;
}
template <class T>
inline vector<pair<int, int> > FACTORIZE(int n) {
if (n > 1e7) return FACTORISE(n);
vector<pair<int, int> > R;
vector<int> a(({
int b = ceil(sqrt(n));
vector<int> d(n, 0);
vector<int> e;
int f = 2;
e.push_back(2);
e.push_back(3);
for (int x = 1; x < b + 1; x++) {
for (int y = 1; y < b + 1; y++) {
int n = (4 * x * x) + (y * y);
if (n <= n && (n % 12 == 1 || n % 12 == 5)) {
d[n] ^= 1;
}
n = (3 * x * x) + (y * y);
if (n <= n && n % 12 == 7) {
d[n] ^= 1;
}
n = (3 * x * x) - (y * y);
if (x > y && n <= n && n % 12 == 11) {
d[n] ^= 1;
}
}
}
for (int r = 5; r < b + 1; r++) {
if (d[r]) {
for (int i = r * r; i < n; i += (r * r)) {
d[i] = 0;
}
}
}
for (int c = 5; c < n; c++) {
if (d[c]) {
e.push_back(c);
}
}
e;
}));
int i;
if (a[({
int z = (lower_bound((a).begin(), (a).end(), n) - (a).begin());
(z == 0 && a[0] != n) ? -1 : z;
})] == n) {
R.push_back(make_pair(n, 1));
return R;
}
int b = (int)sqrt(n);
for (i = 0; a[i] <= b; i++) {
if (n % a[i] == 0) {
int d = 0;
for (; n % a[i] == 0; d++, n /= a[i])
;
R.push_back(make_pair(a[i], d));
}
}
for (; a[i] < n; i++) {
if (n % a[i] == 0) {
R.push_back(make_pair(a[i], 1));
break;
}
}
return R;
}
template <class T>
inline bool IZPRIME(T n) {
if (n <= 1) return false;
for (T i = 2; i * i <= n; i++)
if (n % i == 0) return false;
return true;
}
template <class T>
inline bool ISPRIME(T n) {
if (n > 1e7) return IZPRIME(n);
vector<int> a(({
int b = ceil(sqrt(n));
vector<int> d(n, 0);
vector<int> e;
int f = 2;
e.push_back(2);
e.push_back(3);
for (int x = 1; x < b + 1; x++) {
for (int y = 1; y < b + 1; y++) {
int n = (4 * x * x) + (y * y);
if (n <= n && (n % 12 == 1 || n % 12 == 5)) {
d[n] ^= 1;
}
n = (3 * x * x) + (y * y);
if (n <= n && n % 12 == 7) {
d[n] ^= 1;
}
n = (3 * x * x) - (y * y);
if (x > y && n <= n && n % 12 == 11) {
d[n] ^= 1;
}
}
}
for (int r = 5; r < b + 1; r++) {
if (d[r]) {
for (int i = r * r; i < n; i += (r * r)) {
d[i] = 0;
}
}
}
for (int c = 5; c < n; c++) {
if (d[c]) {
e.push_back(c);
}
}
e;
}));
int b = ({
int z = (lower_bound((a).begin(), (a).end(), n) - (a).begin());
(z == 0 && a[0] != n) ? -1 : z;
});
return (b != -1 && a[b] == n);
}
template <class T>
inline T TOTIENT(T n) {
vector<pair<T, int> > R = FACTORIZE(n);
T r = n;
for (int i = 0; i < R.size(); i++) r = r / R[i].first * (R[i].first - 1);
return r;
}
template <class T>
inline T CHECKMOD(T n, T m) {
return (n % m + m) % m;
}
template <class T>
inline T MULTIPLYMOD(T a, T b, T m) {
return (
T)((((long long)(a) * (long long)(b) % (long long)(m)) + (long long)(m)) %
(long long)(m));
}
template <class T>
inline T DIVIDEMOD(T a, T b, T m) {
T x, y;
EUCLIDEAN(b, m, x, y);
return MULTIPLYMOD(a, x, m);
}
template <class T>
inline T POWERMOD(T p, int e, T m) {
if (e == 0)
return 1 % m;
else if (e % 2 == 0) {
T t = POWERMOD(p, e / 2, m);
return MULTIPLYMOD(t, t, m);
} else
return MULTIPLYMOD(POWERMOD(p, e - 1, m), p, m);
}
template <class T>
inline void SHOWMATRIX(vector<vector<T> >& A) {
for (int i = 0; i < ((int)(A).size()); i++) {
for (int j = 0; j < ((int)(A[0]).size()); j++) cout << A[i][j] << " ";
cout << endl;
}
}
template <class T>
inline void COPYMATRIX(int m, int n, vector<vector<T> >& A,
vector<vector<T> >& B) {
B.clear();
B.resize(n - m + 1, vector<T>(n - m + 1));
for (int i = m, k = 0; i <= n; i++, k++) {
for (int j = m, l = 0; j <= n; j++, l++) B[k][l] = A[i][j];
}
}
template <class T>
inline void IDENTITYMATRIX(int n, vector<vector<T> >& A) {
A.clear();
A.resize(n, vector<T>(n));
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) A[i][j] = (i == j) ? 1 : 0;
}
template <class T, class BinaryOperation>
inline void CHECKMATRIX(vector<vector<T> > A, vector<vector<T> > B,
vector<vector<T> >& C, BinaryOperation b) {
int n = ((int)(A).size());
C.clear();
C.resize(((int)(A).size()), vector<T>(((int)(A).size())));
for (int i = 0; i < ((int)(A).size()); i++)
for (int j = 0; j < ((int)(A[0]).size()); j++)
C[i][j] = b(A[i][j], B[i][j]);
}
template <class T>
inline void mulMatrix(vector<vector<T> > A, vector<vector<T> > B,
vector<vector<T> >& C) {
C.clear();
C.resize(((int)(A).size()), vector<T>(((int)(B[0]).size())));
for (int i = 0; i < ((int)(A).size()); i++)
for (int j = 0; j < ((int)(B[0]).size()); j++)
for (int k = 0; k < ((int)(B).size()); k++) C[i][j] += A[i][k] * B[k][j];
}
template <class T>
inline void TRANSMATRIX(vector<vector<T> >& B, vector<vector<T> >& A) {
B.clear();
B.resize(((int)(A[0]).size()), vector<T>(((int)(A).size())));
for (int i = 0; i < ((int)(B).size()); i++) {
for (int j = 0; j < ((int)(B[0]).size()); j++) B[i][j] = A[j][i];
}
}
template <class T, class BinaryOperation>
inline void SCALARMATRIX(vector<vector<T> >& B, vector<vector<T> >& A, T c,
BinaryOperation d) {
B.clear();
B.resize(((int)(A[0]).size()), vector<T>(((int)(A).size())));
for (int i = 0; i < ((int)(B).size()); i++) {
for (int j = 0; j < ((int)(B[0]).size()); j++) B[i][j] = d(A[j][i], c);
}
}
template <class T>
inline string TOSTRING(T n) {
ostringstream ost;
ost << n;
ost.flush();
return ost.str();
}
template <class T>
inline void TOVAR(string s, T& r) {
istringstream sin(s);
sin >> r;
}
template <class T>
inline void STOV(string s, vector<T>& vi) {
vi.clear();
istringstream sin(s);
for (T v; sin >> v; vi.push_bakc(v))
;
}
template <class T>
inline void VTOS(vector<T> vi, string& s) {
ostringstream sout;
for (int i = 0; i < vi.size(); i++) {
if (i > 0) sout << ' ';
sout << vi[i];
}
s = sout.str();
}
template <class T>
inline vector<T> ATOV(T a[]) {
vector<T> v(a, a + sizeof(a) / sizeof(T));
return v;
}
template <class T>
struct Fraction {
T a, b;
Fraction(T a = 0, T b = 1);
string toString();
};
template <class T>
Fraction<T>::Fraction(T a, T b) {
T d = GCD(a, b);
a /= d;
b /= d;
if (b < 0) a = -a, b = -b;
this->a = a;
this->b = b;
}
template <class T>
string Fraction<T>::toString() {
ostringstream sout;
sout << a << "/" << b;
return sout.str();
}
template <class T>
Fraction<T> operator+(Fraction<T> p, Fraction<T> q) {
return Fraction<T>(p.a * q.b + q.a * p.b, p.b * q.b);
}
template <class T>
Fraction<T> operator-(Fraction<T> p, Fraction<T> q) {
return Fraction<T>(p.a * q.b - q.a * p.b, p.b * q.b);
}
template <class T>
Fraction<T> operator*(Fraction<T> p, Fraction<T> q) {
return Fraction<T>(p.a * q.a, p.b * q.b);
}
template <class T>
Fraction<T> operator/(Fraction<T> p, Fraction<T> q) {
return Fraction<T>(p.a * q.b, p.b * q.a);
}
int main() {
double tmp_start = clock();
fprintf(stderr, "Start\n");
string a;
cin >> a;
string b;
b.push_back(a[((int)(a).size()) - 1]);
for (int i = ((int)(a).size()) - 1 - 1; i >= 0; i--)
if (a[i] >= b[((int)(b).size()) - 1]) b.push_back(a[i]);
reverse((b).begin(), (b).end());
cout << b << "\n";
fprintf(stderr, "Total time = %.2lf sec\n",
(double)(clock() - tmp_start) / CLOCKS_PER_SEC);
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
Even the most successful company can go through a crisis period when you have to make a hard decision — to restructure, discard and merge departments, fire employees and do other unpleasant stuff. Let's consider the following model of a company.
There are n people working for the Large Software Company. Each person belongs to some department. Initially, each person works on his own project in his own department (thus, each company initially consists of n departments, one person in each).
However, harsh times have come to the company and the management had to hire a crisis manager who would rebuild the working process in order to boost efficiency. Let's use team(person) to represent a team where person person works. A crisis manager can make decisions of two types:
1. Merge departments team(x) and team(y) into one large department containing all the employees of team(x) and team(y), where x and y (1 ≤ x, y ≤ n) — are numbers of two of some company employees. If team(x) matches team(y), then nothing happens.
2. Merge departments team(x), team(x + 1), ..., team(y), where x and y (1 ≤ x ≤ y ≤ n) — the numbers of some two employees of the company.
At that the crisis manager can sometimes wonder whether employees x and y (1 ≤ x, y ≤ n) work at the same department.
Help the crisis manager and answer all of his queries.
Input
The first line of the input contains two integers n and q (1 ≤ n ≤ 200 000, 1 ≤ q ≤ 500 000) — the number of the employees of the company and the number of queries the crisis manager has.
Next q lines contain the queries of the crisis manager. Each query looks like type x y, where <image>. If type = 1 or type = 2, then the query represents the decision of a crisis manager about merging departments of the first and second types respectively. If type = 3, then your task is to determine whether employees x and y work at the same department. Note that x can be equal to y in the query of any type.
Output
For each question of type 3 print "YES" or "NO" (without the quotes), depending on whether the corresponding people work in the same department.
Examples
Input
8 6
3 2 5
1 2 5
3 2 5
2 4 7
2 1 2
3 1 7
Output
NO
YES
YES
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct person {
int rank;
int boss;
int skip_to;
};
person **sets;
int findBoss(int p) {
if (sets[p]->boss == p) return p;
int b = findBoss(sets[p]->boss);
sets[p]->boss = b;
return b;
}
void merge(int p, int q) {
int b1 = findBoss(p);
int b2 = findBoss(q);
if (b1 == b2) return;
if (sets[b1]->rank > sets[b2]->rank) {
sets[b2]->boss = b1;
} else if (sets[b1]->rank < sets[b2]->rank) {
sets[b1]->boss = b2;
} else {
sets[b1]->boss = b2;
sets[b2]->rank++;
}
}
int main() {
int n, q;
scanf("%d %d", &n, &q);
sets = (person **)malloc(n * sizeof(person *));
for (int i = 0; i < n; i++) {
person *P = new person;
P->rank = 0;
P->skip_to = i + 1;
P->boss = i;
sets[i] = P;
}
for (int i = 0; i < q; i++) {
int type, x, y;
scanf("%d %d %d", &type, &x, &y);
x--;
y--;
if (type == 1) {
merge(x, y);
} else if (type == 2) {
int index = x;
while (index <= y) {
merge(x, index);
int temp = sets[index]->skip_to;
sets[index]->skip_to = y + 1;
index = temp;
}
} else {
if (findBoss(x) == findBoss(y))
printf("YES\n");
else
printf("NO\n");
}
}
}
``` |
### Prompt
Create a solution in CPP for the following problem:
Think of New York as a rectangular grid consisting of N vertical avenues numerated from 1 to N and M horizontal streets numerated 1 to M. C friends are staying at C hotels located at some street-avenue crossings. They are going to celebrate birthday of one of them in the one of H restaurants also located at some street-avenue crossings. They also want that the maximum distance covered by one of them while traveling to the restaurant to be minimum possible. Help friends choose optimal restaurant for a celebration.
Suppose that the distance between neighboring crossings are all the same equal to one kilometer.
Input
The first line contains two integers N и M — size of the city (1 ≤ N, M ≤ 109). In the next line there is a single integer C (1 ≤ C ≤ 105) — the number of hotels friends stayed at. Following C lines contain descriptions of hotels, each consisting of two coordinates x and y (1 ≤ x ≤ N, 1 ≤ y ≤ M). The next line contains an integer H — the number of restaurants (1 ≤ H ≤ 105). Following H lines contain descriptions of restaurants in the same format.
Several restaurants and hotels may be located near the same crossing.
Output
In the first line output the optimal distance. In the next line output index of a restaurant that produces this optimal distance. If there are several possibilities, you are allowed to output any of them.
Examples
Input
10 10
2
1 1
3 3
2
1 10
4 4
Output
6
2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m, c, h, x, y;
int hx[5], hy[5];
int d[5];
int main() {
for (int i = 1; i <= 4; i++) {
d[i] = 2000000002;
}
scanf("%d %d", &n, &m);
scanf("%d", &c);
int cs = 0;
int titik[5], flag = 0;
for (int i = 0; i < c; i++) {
scanf("%d %d", &x, &y);
titik[1] = (abs(x - 1) + abs(y - 1));
titik[2] = (abs(x - n) + abs(y - m));
titik[3] = abs(x - 1) + abs(y - m);
titik[4] = abs(x - n) + abs(y - 1);
cs = 0;
for (int j = 1; j <= 4; j++) {
if (titik[j] < d[j]) {
hx[j] = x;
hy[j] = y;
d[j] = titik[j];
}
}
}
scanf("%d", &h);
int mx = 2000000001;
int mxmx = -100000;
int num = 0;
for (int i = 1; i <= h; i++) {
scanf("%d %d", &x, &y);
mxmx = -100000;
for (int j = 1; j <= 4; j++) {
mxmx = max(mxmx, abs(hx[j] - x) + abs(hy[j] - y));
}
if (mxmx < mx) {
mx = mxmx;
num = i;
}
}
printf("%d\n%d\n", mx, num);
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
By the age of three Smart Beaver mastered all arithmetic operations and got this summer homework from the amazed teacher:
You are given a sequence of integers a1, a2, ..., an. Your task is to perform on it m consecutive operations of the following type:
1. For given numbers xi and vi assign value vi to element axi.
2. For given numbers li and ri you've got to calculate sum <image>, where f0 = f1 = 1 and at i ≥ 2: fi = fi - 1 + fi - 2.
3. For a group of three numbers li ri di you should increase value ax by di for all x (li ≤ x ≤ ri).
Smart Beaver planned a tour around great Canadian lakes, so he asked you to help him solve the given problem.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 2·105) — the number of integers in the sequence and the number of operations, correspondingly. The second line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 105). Then follow m lines, each describes an operation. Each line starts with an integer ti (1 ≤ ti ≤ 3) — the operation type:
* if ti = 1, then next follow two integers xi vi (1 ≤ xi ≤ n, 0 ≤ vi ≤ 105);
* if ti = 2, then next follow two integers li ri (1 ≤ li ≤ ri ≤ n);
* if ti = 3, then next follow three integers li ri di (1 ≤ li ≤ ri ≤ n, 0 ≤ di ≤ 105).
The input limits for scoring 30 points are (subproblem E1):
* It is guaranteed that n does not exceed 100, m does not exceed 10000 and there will be no queries of the 3-rd type.
The input limits for scoring 70 points are (subproblems E1+E2):
* It is guaranteed that there will be queries of the 1-st and 2-nd type only.
The input limits for scoring 100 points are (subproblems E1+E2+E3):
* No extra limitations.
Output
For each query print the calculated sum modulo 1000000000 (109).
Examples
Input
5 5
1 3 1 2 4
2 1 4
2 1 5
2 2 4
1 3 10
2 1 5
Output
12
32
8
50
Input
5 4
1 3 1 2 4
3 1 4 1
2 2 4
1 2 10
2 1 5
Output
12
45
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:200000000")
const double EPS = 1E-9;
const int INF = 1000000000;
const long long INF64 = (long long)1E18;
const double PI = 3.1415926535897932384626433832795;
const int NMAX = 810000;
const long long MOD = INF;
long long a[NMAX], f[NMAX], md[NMAX][2], rel[NMAX], sum[NMAX];
inline long long get(int idx, int s) {
if (s <= 1) return md[idx][s];
return (md[idx][0] * f[s - 2] + md[idx][1] * f[s - 1]) % MOD;
}
inline void calc(int idx, int l, int r) {
int mid = (l + r) >> 1;
md[idx][0] = (md[idx << 1][0] + get(idx << 1 | 1, mid + 1 - l)) % MOD;
md[idx][1] = (md[idx << 1][1] + get(idx << 1 | 1, mid + 2 - l)) % MOD;
}
inline void relax(int idx, int l, int r) {
if (rel[idx]) {
md[idx][0] = (md[idx][0] + sum[r - l] * rel[idx]) % MOD;
md[idx][1] = (md[idx][1] + (sum[r - l + 1] - 1 + MOD) * rel[idx]) % MOD;
if (l != r) {
rel[idx << 1] = (rel[idx << 1] + rel[idx]) % MOD;
rel[idx << 1 | 1] = (rel[idx << 1 | 1] + rel[idx]) % MOD;
}
rel[idx] = 0;
}
}
void build(int idx, int l, int r) {
if (l == r) {
md[idx][0] = md[idx][1] = a[l];
return;
}
int mid = (l + r) >> 1;
build(idx << 1, l, mid);
build(idx << 1 | 1, mid + 1, r);
calc(idx, l, r);
}
long long get(int idx, int l, int r, int a, int b) {
relax(idx, l, r);
if (b < l || r < a) return 0;
if (a <= l && r <= b) return get(idx, l - a);
int mid = (l + r) >> 1;
long long res = 0;
res += get(idx << 1, l, mid, a, b);
res += get(idx << 1 | 1, mid + 1, r, a, b);
res %= MOD;
calc(idx, l, r);
return res;
}
void assign(int idx, int l, int r, int pos, int val) {
relax(idx, l, r);
if (pos < l || r < pos) return;
if (l == r) {
md[idx][0] = md[idx][1] = val;
return;
}
int mid = (l + r) >> 1;
assign(idx << 1, l, mid, pos, val);
assign(idx << 1 | 1, mid + 1, r, pos, val);
calc(idx, l, r);
}
void update(int idx, int l, int r, int a, int b, int val) {
relax(idx, l, r);
if (b < l || r < a) return;
if (a <= l && r <= b) {
rel[idx] = val;
return relax(idx, l, r);
}
int mid = (l + r) >> 1;
update(idx << 1, l, mid, a, b, val);
update(idx << 1 | 1, mid + 1, r, a, b, val);
calc(idx, l, r);
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < (int)(n); i++) {
int val;
scanf("%d", &val);
a[i] = val;
}
f[0] = f[1] = 1;
sum[0] = 1;
sum[1] = 2;
for (int i = 2; i < NMAX; i++) {
f[i] = (f[i - 2] + f[i - 1]) % MOD;
sum[i] = (sum[i - 1] + f[i]) % MOD;
}
build(1, 0, n - 1);
for (int ii = 0; ii < (int)(m); ii++) {
int tp;
scanf("%d", &tp);
if (tp == 1) {
int x, v;
scanf("%d%d", &x, &v);
x--;
assign(1, 0, n - 1, x, v);
} else if (tp == 2) {
int l, r;
scanf("%d%d", &l, &r);
l--;
r--;
int res = (int)get(1, 0, n - 1, l, r);
printf("%d\n", res);
} else {
int l, r, v;
scanf("%d%d%d", &l, &r, &v);
l--;
r--;
update(1, 0, n - 1, l, r, v);
}
}
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
You have got a shelf and want to put some books on it.
You are given q queries of three types:
1. L id — put a book having index id on the shelf to the left from the leftmost existing book;
2. R id — put a book having index id on the shelf to the right from the rightmost existing book;
3. ? id — calculate the minimum number of books you need to pop from the left or from the right in such a way that the book with index id will be leftmost or rightmost.
You can assume that the first book you will put can have any position (it does not matter) and queries of type 3 are always valid (it is guaranteed that the book in each such query is already placed). You can also assume that you don't put the same book on the shelf twice, so ids don't repeat in queries of first two types.
Your problem is to answer all the queries of type 3 in order they appear in the input.
Note that after answering the query of type 3 all the books remain on the shelf and the relative order of books does not change.
If you are Python programmer, consider using PyPy instead of Python when you submit your code.
Input
The first line of the input contains one integer q (1 ≤ q ≤ 2 ⋅ 10^5) — the number of queries.
Then q lines follow. The i-th line contains the i-th query in format as in the problem statement. It is guaranteed that queries are always valid (for query type 3, it is guaranteed that the book in each such query is already placed, and for other types, it is guaranteed that the book was not placed before).
It is guaranteed that there is at least one query of type 3 in the input.
In each query the constraint 1 ≤ id ≤ 2 ⋅ 10^5 is met.
Output
Print answers to queries of the type 3 in order they appear in the input.
Examples
Input
8
L 1
R 2
R 3
? 2
L 4
? 1
L 5
? 1
Output
1
1
2
Input
10
L 100
R 100000
R 123
L 101
? 123
L 10
R 115
? 100
R 110
? 115
Output
0
2
1
Note
Let's take a look at the first example and let's consider queries:
1. The shelf will look like [1];
2. The shelf will look like [1, 2];
3. The shelf will look like [1, 2, 3];
4. The shelf looks like [1, 2, 3] so the answer is 1;
5. The shelf will look like [4, 1, 2, 3];
6. The shelf looks like [4, 1, 2, 3] so the answer is 1;
7. The shelf will look like [5, 4, 1, 2, 3];
8. The shelf looks like [5, 4, 1, 2, 3] so the answer is 2.
Let's take a look at the second example and let's consider queries:
1. The shelf will look like [100];
2. The shelf will look like [100, 100000];
3. The shelf will look like [100, 100000, 123];
4. The shelf will look like [101, 100, 100000, 123];
5. The shelf looks like [101, 100, 100000, 123] so the answer is 0;
6. The shelf will look like [10, 101, 100, 100000, 123];
7. The shelf will look like [10, 101, 100, 100000, 123, 115];
8. The shelf looks like [10, 101, 100, 100000, 123, 115] so the answer is 2;
9. The shelf will look like [10, 101, 100, 100000, 123, 115, 110];
10. The shelf looks like [10, 101, 100, 100000, 123, 115, 110] so the answer is 1.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int q;
cin >> q;
map<int, int> m;
int left(-1), right(1);
char a;
int w;
cin >> a;
cin >> w;
m[w] = 0;
q--;
while (q--) {
cin >> a >> w;
if (a == 'R') {
m[w] = right++;
} else if (a == 'L') {
m[w] = left--;
} else {
cout << min(right - m[w] - 1, abs(left - m[w]) - 1) << endl;
}
}
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
George decided to prepare a Codesecrof round, so he has prepared m problems for the round. Let's number the problems with integers 1 through m. George estimates the i-th problem's complexity by integer bi.
To make the round good, he needs to put at least n problems there. Besides, he needs to have at least one problem with complexity exactly a1, at least one with complexity exactly a2, ..., and at least one with complexity exactly an. Of course, the round can also have problems with other complexities.
George has a poor imagination. It's easier for him to make some already prepared problem simpler than to come up with a new one and prepare it. George is magnificent at simplifying problems. He can simplify any already prepared problem with complexity c to any positive integer complexity d (c ≥ d), by changing limits on the input data.
However, nothing is so simple. George understood that even if he simplifies some problems, he can run out of problems for a good round. That's why he decided to find out the minimum number of problems he needs to come up with in addition to the m he's prepared in order to make a good round. Note that George can come up with a new problem of any complexity.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 3000) — the minimal number of problems in a good round and the number of problems George's prepared. The second line contains space-separated integers a1, a2, ..., an (1 ≤ a1 < a2 < ... < an ≤ 106) — the requirements for the complexity of the problems in a good round. The third line contains space-separated integers b1, b2, ..., bm (1 ≤ b1 ≤ b2... ≤ bm ≤ 106) — the complexities of the problems prepared by George.
Output
Print a single integer — the answer to the problem.
Examples
Input
3 5
1 2 3
1 2 2 3 3
Output
0
Input
3 5
1 2 3
1 1 1 1 1
Output
2
Input
3 1
2 3 4
1
Output
3
Note
In the first sample the set of the prepared problems meets the requirements for a good round.
In the second sample, it is enough to come up with and prepare two problems with complexities 2 and 3 to get a good round.
In the third sample it is very easy to get a good round if come up with and prepare extra problems with complexities: 2, 3, 4.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, i, t, m;
cin >> n >> m;
vector<long long> a(n);
vector<long long> b(m);
for (i = 0; i < n; i++) {
cin >> a[i];
}
for (i = 0; i < m; i++) {
cin >> b[i];
}
i = 0;
long long j = 0;
sort(a.begin(), a.end());
while (i < n && j < m) {
if (a[i] <= b[j]) {
i++;
j++;
} else {
j++;
}
}
cout << n - i;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
Monocarp has decided to buy a new TV set and hang it on the wall in his flat. The wall has enough free space so Monocarp can buy a TV set with screen width not greater than a and screen height not greater than b. Monocarp is also used to TV sets with a certain aspect ratio: formally, if the width of the screen is w, and the height of the screen is h, then the following condition should be met: w/h = x/y.
There are many different TV sets in the shop. Monocarp is sure that for any pair of positive integers w and h there is a TV set with screen width w and height h in the shop.
Monocarp isn't ready to choose the exact TV set he is going to buy. Firstly he wants to determine the optimal screen resolution. He has decided to try all possible variants of screen size. But he must count the number of pairs of positive integers w and h, beforehand, such that (w ≤ a), (h ≤ b) and (w/h = x/y).
In other words, Monocarp wants to determine the number of TV sets having aspect ratio x/y, screen width not exceeding a, and screen height not exceeding b. Two TV sets are considered different if they have different screen width or different screen height.
Input
The first line contains four integers a, b, x, y (1 ≤ a, b, x, y ≤ 10^{18}) — the constraints on the screen width and height, and on the aspect ratio.
Output
Print one integer — the number of different variants to choose TV screen width and screen height so that they meet the aforementioned constraints.
Examples
Input
17 15 5 3
Output
3
Input
14 16 7 22
Output
0
Input
4 2 6 4
Output
1
Input
1000000000000000000 1000000000000000000 999999866000004473 999999822000007597
Output
1000000063
Note
In the first example, there are 3 possible variants: (5, 3), (10, 6), (15, 9).
In the second example, there is no TV set meeting the constraints.
In the third example, there is only one variant: (3, 2).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
long long int i, j, k, n, ans = 0, t, a, b, x, y;
cin >> a >> b >> x >> y;
j = gcd(x, y);
x = x / j;
y = y / j;
cout << min(a / x, b / y);
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
Write a program which reads an directed graph $G = (V, E)$, and finds the shortest distance from vertex $1$ to each vertex (the number of edges in the shortest path). Vertices are identified by IDs $1, 2, ... n$.
Constraints
* $1 \leq n \leq 100$
Input
In the first line, an integer $n$ denoting the number of vertices, is given. In the next $n$ lines, adjacent lists of vertex $u$ are given in the following format:
$u$ $k$ $v_1$ $v_2$ ... $v_k$
$u$ is ID of the vertex and $k$ denotes its degree.$v_i$ are IDs of vertices adjacent to $u$.
Output
For each vertex $u$, print $id$ and $d$ in a line. $id$ is ID of vertex $u$ and $d$ is the distance from vertex $1$ to vertex $u$. If there are no path from vertex $1$ to vertex $u$, print -1 as the shortest distance. Print in order of IDs.
Example
Input
4
1 2 2 4
2 1 4
3 0
4 1 3
Output
1 0
2 1
3 2
4 1
### Response
```cpp
#include <iostream>
#include <queue>
#include <algorithm>
using namespace std;
int M[101][101], d[101], n;
void set()
{
int u, k, v;
for (int i = 0; i < n; i++) {
cin >> u >> k;
for (int j = 0; j < k; j++) {
cin >> v;
M[u][v] = 1;
}
}
for (int i = 1; i <= n; i++)
d[i] = -1;
}
void bfs(int x)
{
queue<int> Q;
Q.push(x);
d[x] = 0;
while (!Q.empty()) {
int u = Q.front();
for (int i = 1; i <= n; i++) {
if (M[u][i] == 1 && d[i] == -1) {
Q.push(i);
d[i] = d[u] + 1;
}
}
Q.pop();
}
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
set();
bfs(1);
for (int i = 1; i <= n; i++)
cout << i << " " << d[i] << endl;
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
An adult game master and N children are playing a game on an ice rink. The game consists of K rounds. In the i-th round, the game master announces:
* Form groups consisting of A_i children each!
Then the children who are still in the game form as many groups of A_i children as possible. One child may belong to at most one group. Those who are left without a group leave the game. The others proceed to the next round. Note that it's possible that nobody leaves the game in some round.
In the end, after the K-th round, there are exactly two children left, and they are declared the winners.
You have heard the values of A_1, A_2, ..., A_K. You don't know N, but you want to estimate it.
Find the smallest and the largest possible number of children in the game before the start, or determine that no valid values of N exist.
Constraints
* 1 \leq K \leq 10^5
* 2 \leq A_i \leq 10^9
* All input values are integers.
Input
Input is given from Standard Input in the following format:
K
A_1 A_2 ... A_K
Output
Print two integers representing the smallest and the largest possible value of N, respectively, or a single integer -1 if the described situation is impossible.
Examples
Input
4
3 4 3 2
Output
6 8
Input
5
3 4 100 3 2
Output
-1
Input
10
2 2 2 2 2 2 2 2 2 2
Output
2 3
### Response
```cpp
#include<cstdio>
int main(){
long long K,A[100000];
scanf("%lld",&K);
for(int i=0;i<K;i++)scanf("%lld",A+i);
long long min=2,max=2;
for(int i=K-1;i>=0;i--){
if(min%A[i])min+=A[i]-min%A[i];
if(max%A[i])max+=-max%A[i];
if(min>max){
printf("-1");
return 0;
}
else max+=A[i]-1;
}
printf("%lld %lld",min,max);
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
Iahub does not like background stories, so he'll tell you exactly what this problem asks you for.
You are given a matrix a with n rows and n columns. Initially, all values of the matrix are zeros. Both rows and columns are 1-based, that is rows are numbered 1, 2, ..., n and columns are numbered 1, 2, ..., n. Let's denote an element on the i-th row and j-th column as ai, j.
We will call a submatrix (x0, y0, x1, y1) such elements ai, j for which two inequalities hold: x0 ≤ i ≤ x1, y0 ≤ j ≤ y1.
Write a program to perform two following operations:
1. Query(x0, y0, x1, y1): print the xor sum of the elements of the submatrix (x0, y0, x1, y1).
2. Update(x0, y0, x1, y1, v): each element from submatrix (x0, y0, x1, y1) gets xor-ed by value v.
Input
The first line contains two integers: n (1 ≤ n ≤ 1000) and m (1 ≤ m ≤ 105). The number m represents the number of operations you need to perform. Each of the next m lines contains five or six integers, depending on operation type.
If the i-th operation from the input is a query, the first number from i-th line will be 1. It will be followed by four integers x0, y0, x1, y1. If the i-th operation is an update, the first number from the i-th line will be 2. It will be followed by five integers x0, y0, x1, y1, v.
It is guaranteed that for each update operation, the following inequality holds: 0 ≤ v < 262. It is guaranteed that for each operation, the following inequalities hold: 1 ≤ x0 ≤ x1 ≤ n, 1 ≤ y0 ≤ y1 ≤ n.
Output
For each query operation, output on a new line the result.
Examples
Input
3 5
2 1 1 2 2 1
2 1 3 2 3 2
2 3 1 3 3 3
1 2 2 3 3
1 2 2 3 2
Output
3
2
Note
After the first 3 operations, the matrix will look like this:
1 1 2
1 1 2
3 3 3
The fourth operation asks us to compute 1 xor 2 xor 3 xor 3 = 3.
The fifth operation asks us to compute 1 xor 3 = 2.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (1 << 10);
template <class T>
struct fenwick {
int sz;
T tr[MAXN];
void init(int n) {
sz = n + 1;
memset(tr, 0, sizeof(tr));
}
T query(int idx) {
T ans = 0;
for (; idx >= 1; idx -= (idx & -idx)) ans ^= tr[idx];
return ans;
}
void update(int idx, T val) {
if (idx <= 0) return;
for (; idx <= sz; idx += (idx & -idx)) tr[idx] ^= val;
}
T query(int l, int r) { return query(r) ^ query(l - 1); }
};
template <class T>
struct fenwick_2d {
int sz;
fenwick<T> tr[MAXN];
void init(int n) {
sz = n + 1;
for (int i = 1; i <= sz; i++) tr[i].init(n);
}
T query(int x, int y) {
T ans = 0;
for (; x >= 1; x -= (x & -x)) ans ^= tr[x].query(y);
return ans;
}
void update(int x, int y, T val) {
if (x <= 0) return;
for (; x <= sz; x += (x & -x)) tr[x].update(y, val);
}
};
int n, m;
fenwick_2d<int64_t> t[4];
void read() { cin >> n >> m; }
int64_t query(int x, int y) { return t[((x & 1) << 1) | (y & 1)].query(x, y); }
void update(int x, int y, int64_t val) {
t[((x & 1) << 1) | (y & 1)].update(x, y, val);
}
void solve() {
for (int idx = 0; idx < 4; idx++) t[idx].init(n);
for (int i = 0; i < m; i++) {
int type, x0, y0, x1, y1;
cin >> type >> x0 >> y0 >> x1 >> y1;
if (type == 1)
cout << (query(x1, y1) ^ query(x0 - 1, y1) ^ query(x1, y0 - 1) ^
query(x0 - 1, y0 - 1))
<< '\n';
else {
int64_t val;
cin >> val;
update(x0, y0, val);
update(x1 + 1, y0, val);
update(x0, y1 + 1, val);
update(x1 + 1, y1 + 1, val);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
read();
solve();
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
Little Chris is a huge fan of linear algebra. This time he has been given a homework about the unusual square of a square matrix.
The dot product of two integer number vectors x and y of size n is the sum of the products of the corresponding components of the vectors. The unusual square of an n × n square matrix A is defined as the sum of n dot products. The i-th of them is the dot product of the i-th row vector and the i-th column vector in the matrix A.
Fortunately for Chris, he has to work only in GF(2)! This means that all operations (addition, multiplication) are calculated modulo 2. In fact, the matrix A is binary: each element of A is either 0 or 1. For example, consider the following matrix A:
<image>
The unusual square of A is equal to (1·1 + 1·0 + 1·1) + (0·1 + 1·1 + 1·0) + (1·1 + 0·1 + 0·0) = 0 + 1 + 1 = 0.
However, there is much more to the homework. Chris has to process q queries; each query can be one of the following:
1. given a row index i, flip all the values in the i-th row in A;
2. given a column index i, flip all the values in the i-th column in A;
3. find the unusual square of A.
To flip a bit value w means to change it to 1 - w, i.e., 1 changes to 0 and 0 changes to 1.
Given the initial matrix A, output the answers for each query of the third type! Can you solve Chris's homework?
Input
The first line of input contains an integer n (1 ≤ n ≤ 1000), the number of rows and the number of columns in the matrix A. The next n lines describe the matrix: the i-th line contains n space-separated bits and describes the i-th row of A. The j-th number of the i-th line aij (0 ≤ aij ≤ 1) is the element on the intersection of the i-th row and the j-th column of A.
The next line of input contains an integer q (1 ≤ q ≤ 106), the number of queries. Each of the next q lines describes a single query, which can be one of the following:
* 1 i — flip the values of the i-th row;
* 2 i — flip the values of the i-th column;
* 3 — output the unusual square of A.
Note: since the size of the input and output could be very large, don't use slow output techniques in your language. For example, do not use input and output streams (cin, cout) in C++.
Output
Let the number of the 3rd type queries in the input be m. Output a single string s of length m, where the i-th symbol of s is the value of the unusual square of A for the i-th query of the 3rd type as it appears in the input.
Examples
Input
3
1 1 1
0 1 1
1 0 0
12
3
2 3
3
2 2
2 2
1 3
3
3
1 2
2 1
1 1
3
Output
01001
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
static const double EPS = 1e-5;
int main() {
int n;
scanf("%d", &n);
int matrix[n][n];
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) scanf("%d", &matrix[i][j]);
int score[n][4];
int curbit[n];
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 4; j++) score[i][j] = 0;
for (int j = 0; j < n; j++) {
if (i == j) continue;
score[i][matrix[i][j] * 2 + matrix[j][i]]++;
}
for (int j = 0; j < 4; j++) {
score[i][j] %= 2;
}
curbit[i] = 3;
ans += score[i][3];
if (matrix[i][i] == 1) ans++;
}
int q;
cin >> q;
ans %= 2;
string output = "";
for (int i = 0; i < q; i++) {
int op;
scanf("%d", &op);
if (op == 3) {
output += char('0' + ans);
} else if (op == 1) {
int r;
scanf("%d", &r);
ans++;
} else if (op == 2) {
int r;
scanf("%d", &r);
ans++;
}
ans %= 2;
}
cout << output << endl;
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
Old MacDonald has a farm and a large potato field, (1010 + 1) × (1010 + 1) square meters in size. The field is divided into square garden beds, each bed takes up one square meter.
Old McDonald knows that the Colorado potato beetle is about to invade his farm and can destroy the entire harvest. To fight the insects, Old McDonald wants to spray some beds with insecticides.
So Old McDonald went to the field, stood at the center of the central field bed and sprayed this bed with insecticides. Now he's going to make a series of movements and spray a few more beds. During each movement Old McDonald moves left, right, up or down the field some integer number of meters. As Old McDonald moves, he sprays all the beds he steps on. In other words, the beds that have any intersection at all with Old McDonald's trajectory, are sprayed with insecticides.
When Old McDonald finished spraying, he wrote out all his movements on a piece of paper. Now he wants to know how many beds won't be infected after the invasion of the Colorado beetles.
It is known that the invasion of the Colorado beetles goes as follows. First some bed on the field border gets infected. Than any bed that hasn't been infected, hasn't been sprayed with insecticides and has a common side with an infected bed, gets infected as well. Help Old McDonald and determine the number of beds that won't be infected by the Colorado potato beetle.
Input
The first line contains an integer n (1 ≤ n ≤ 1000) — the number of Old McDonald's movements.
Next n lines contain the description of Old McDonald's movements. The i-th of these lines describes the i-th movement. Each movement is given in the format "di xi", where di is the character that determines the direction of the movement ("L", "R", "U" or "D" for directions "left", "right", "up" and "down", correspondingly), and xi (1 ≤ xi ≤ 106) is an integer that determines the number of meters in the movement.
Output
Print a single integer — the number of beds that won't be infected by the Colorado potato beetle.
Please do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
5
R 8
U 9
L 9
D 8
L 2
Output
101
Input
7
R 10
D 2
L 7
U 9
D 2
R 3
D 10
Output
52
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long cx, cy, n, x[2000];
string dir[2000];
set<long> dx, dy;
set<long>::iterator it;
map<long, long> mx, my, rmx, rmy;
long val;
long calcx, calcy;
long nx, ny;
bool forb[(1 << 12) + 100][(1 << 12) + 100];
bool used[(1 << 12) + 100][(1 << 12) + 100];
long long ans;
bool cmove(long a, long b) {
if (a <= 0 || b <= 0 || a > calcx || b > calcy) return false;
if (used[a][b]) return false;
if (forb[a][b]) return false;
return true;
}
void dfs(long a, long b) {
used[a][b] = 1;
if (cmove(a - 1, b)) dfs(a - 1, b);
if (cmove(a + 1, b)) dfs(a + 1, b);
if (cmove(a, b - 1)) dfs(a, b - 1);
if (cmove(a, b + 1)) dfs(a, b + 1);
}
void ap(long x, long y) {
dx.insert(x);
dy.insert(y);
dx.insert(x + 1);
dy.insert(y + 1);
}
int main() {
ios_base::sync_with_stdio(0);
cx = cy = 1000000000;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> dir[i] >> x[i];
ap(cx, cy);
if (dir[i] == "U") cx -= x[i];
if (dir[i] == "D") cx += x[i];
if (dir[i] == "L") cy -= x[i];
if (dir[i] == "R") cy += x[i];
}
ap(cx, cy);
ap(1, 1);
for (it = dx.begin(); it != dx.end(); it++) {
val = (*it);
++calcx;
mx[val] = calcx;
rmx[calcx] = val;
}
for (it = dy.begin(); it != dy.end(); it++) {
val = (*it);
++calcy;
my[val] = calcy;
rmy[calcy] = val;
}
cx = cy = 1000000000;
for (int i = 1; i <= n; i++) {
nx = cx;
ny = cy;
if (dir[i] == "U") {
nx -= x[i];
for (int j = mx[nx]; j <= mx[cx]; j++) forb[j][my[cy]] = 1;
}
if (dir[i] == "D") {
nx += x[i];
for (int j = mx[cx]; j <= mx[nx]; j++) forb[j][my[cy]] = 1;
}
if (dir[i] == "L") {
ny -= x[i];
for (int j = my[ny]; j <= my[cy]; j++) forb[mx[cx]][j] = 1;
}
if (dir[i] == "R") {
ny += x[i];
for (int j = my[cy]; j <= my[ny]; j++) forb[mx[cx]][j] = 1;
}
cx = nx;
cy = ny;
}
dfs(1, 1);
for (int i = 1; i <= calcx; i++)
for (int j = 1; j <= calcy; j++) {
if (used[i][j]) continue;
ans += (rmx[i + 1] - rmx[i]) * 1ll * (rmy[j + 1] - rmy[j]);
}
cout << ans << endl;
cin.get();
cin.get();
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
AtCoDeer the deer is going on a trip in a two-dimensional plane. In his plan, he will depart from point (0, 0) at time 0, then for each i between 1 and N (inclusive), he will visit point (x_i,y_i) at time t_i.
If AtCoDeer is at point (x, y) at time t, he can be at one of the following points at time t+1: (x+1,y), (x-1,y), (x,y+1) and (x,y-1). Note that he cannot stay at his place. Determine whether he can carry out his plan.
Constraints
* 1 ≤ N ≤ 10^5
* 0 ≤ x_i ≤ 10^5
* 0 ≤ y_i ≤ 10^5
* 1 ≤ t_i ≤ 10^5
* t_i < t_{i+1} (1 ≤ i ≤ N-1)
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
t_1 x_1 y_1
t_2 x_2 y_2
:
t_N x_N y_N
Output
If AtCoDeer can carry out his plan, print `Yes`; if he cannot, print `No`.
Examples
Input
2
3 1 2
6 1 1
Output
Yes
Input
1
2 100 100
Output
No
Input
2
5 1 1
100 1 1
Output
No
### Response
```cpp
#include<iostream>
using namespace std;
int main(){
int n,t,x,y;
cin>>n;
for(int i=1;i<=n;i++){
cin>>t>>x>>y;
if((x+y>t)||((x+y)%2==0&&t%2==1)||((x+y)%2==1&&t%2==0)){
cout<<"No"<<endl;
return 0;}
}
cout<<"Yes"<<endl;}
``` |
### Prompt
Create a solution in CPP for the following problem:
Dawid has four bags of candies. The i-th of them contains a_i candies. Also, Dawid has two friends. He wants to give each bag to one of his two friends. Is it possible to distribute the bags in such a way that each friend receives the same amount of candies in total?
Note, that you can't keep bags for yourself or throw them away, each bag should be given to one of the friends.
Input
The only line contains four integers a_1, a_2, a_3 and a_4 (1 ≤ a_i ≤ 100) — the numbers of candies in each bag.
Output
Output YES if it's possible to give the bags to Dawid's friends so that both friends receive the same amount of candies, or NO otherwise. Each character can be printed in any case (either uppercase or lowercase).
Examples
Input
1 7 11 5
Output
YES
Input
7 3 2 5
Output
NO
Note
In the first sample test, Dawid can give the first and the third bag to the first friend, and the second and the fourth bag to the second friend. This way, each friend will receive 12 candies.
In the second sample test, it's impossible to distribute the bags.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> arr(4, 0);
int sum = 0;
for (int i = 0; i < 4; i++) {
cin >> arr[i];
sum += arr[i];
}
if (sum % 2 == 1) {
cout << "NO" << endl;
goto done;
}
sum /= 2;
if (arr[3] == sum) {
cout << "YES" << endl;
goto done;
}
for (int i = 2; i >= 0; i--)
if (arr[i] + arr[3] == sum) {
cout << "YES" << endl;
goto done;
}
for (int i = 2; i >= 0; i--) {
for (int j = i - 1; j >= 0; j--)
if (arr[i] + arr[j] + arr[3] == sum) {
cout << "YES" << endl;
goto done;
}
}
cout << "NO" << endl;
done:
return 0;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
Polycarp likes arithmetic progressions. A sequence [a_1, a_2, ..., a_n] is called an arithmetic progression if for each i (1 ≤ i < n) the value a_{i+1} - a_i is the same. For example, the sequences [42], [5, 5, 5], [2, 11, 20, 29] and [3, 2, 1, 0] are arithmetic progressions, but [1, 0, 1], [1, 3, 9] and [2, 3, 1] are not.
It follows from the definition that any sequence of length one or two is an arithmetic progression.
Polycarp found some sequence of positive integers [b_1, b_2, ..., b_n]. He agrees to change each element by at most one. In the other words, for each element there are exactly three options: an element can be decreased by 1, an element can be increased by 1, an element can be left unchanged.
Determine a minimum possible number of elements in b which can be changed (by exactly one), so that the sequence b becomes an arithmetic progression, or report that it is impossible.
It is possible that the resulting sequence contains element equals 0.
Input
The first line contains a single integer n (1 ≤ n ≤ 100 000) — the number of elements in b.
The second line contains a sequence b_1, b_2, ..., b_n (1 ≤ b_i ≤ 10^{9}).
Output
If it is impossible to make an arithmetic progression with described operations, print -1. In the other case, print non-negative integer — the minimum number of elements to change to make the given sequence becomes an arithmetic progression. The only allowed operation is to add/to subtract one from an element (can't use operation twice to the same position).
Examples
Input
4
24 21 14 10
Output
3
Input
2
500 500
Output
0
Input
3
14 5 1
Output
-1
Input
5
1 3 6 9 12
Output
1
Note
In the first example Polycarp should increase the first number on 1, decrease the second number on 1, increase the third number on 1, and the fourth number should left unchanged. So, after Polycarp changed three elements by one, his sequence became equals to [25, 20, 15, 10], which is an arithmetic progression.
In the second example Polycarp should not change anything, because his sequence is an arithmetic progression.
In the third example it is impossible to make an arithmetic progression.
In the fourth example Polycarp should change only the first element, he should decrease it on one. After that his sequence will looks like [0, 3, 6, 9, 12], which is an arithmetic progression.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const long long maxn = 3e6;
const long long mod = 1e9 + 7;
const long double PI = acos((long double)-1);
long long pw(long long a, long long b, long long md = mod) {
long long res = 1;
while (b) {
if (b & 1) {
res = (a * res) % md;
}
a = (a * a) % md;
b >>= 1;
}
return (res);
}
int mn = 1e9;
int n;
long long a[maxn];
long long b[maxn];
int solve(int x, int y) {
int ans = 0;
if (x != 0) {
ans++;
}
if (y != 0) {
ans++;
}
a[0] += x;
a[1] += y;
long long jump = a[1] - a[0];
for (long long i = 0; i < n; i++) {
if (a[i] != a[0] + i * jump) {
if (abs(a[i] - (a[0] + i * jump)) > 1) {
return (1e9);
}
ans++;
}
}
return (ans);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
if (n <= 2) {
cout << 0;
return (0);
;
}
for (int i = 0; i < n; i++) {
cin >> a[i];
b[i] = a[i];
}
int d[] = {-1, 0, 1};
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
mn = min(mn, solve(d[i], d[j]));
for (int i = 0; i < n; i++) {
a[i] = b[i];
}
}
}
if (mn == 1e9) {
cout << -1;
return (0);
}
cout << mn;
return (0);
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
While Farmer John rebuilds his farm in an unfamiliar portion of Bovinia, Bessie is out trying some alternative jobs. In her new gig as a reporter, Bessie needs to know about programming competition results as quickly as possible. When she covers the 2016 Robot Rap Battle Tournament, she notices that all of the robots operate under deterministic algorithms. In particular, robot i will beat robot j if and only if robot i has a higher skill level than robot j. And if robot i beats robot j and robot j beats robot k, then robot i will beat robot k. Since rapping is such a subtle art, two robots can never have the same skill level.
Given the results of the rap battles in the order in which they were played, determine the minimum number of first rap battles that needed to take place before Bessie could order all of the robots by skill level.
Input
The first line of the input consists of two integers, the number of robots n (2 ≤ n ≤ 100 000) and the number of rap battles m (<image>).
The next m lines describe the results of the rap battles in the order they took place. Each consists of two integers ui and vi (1 ≤ ui, vi ≤ n, ui ≠ vi), indicating that robot ui beat robot vi in the i-th rap battle. No two rap battles involve the same pair of robots.
It is guaranteed that at least one ordering of the robots satisfies all m relations.
Output
Print the minimum k such that the ordering of the robots by skill level is uniquely defined by the first k rap battles. If there exists more than one ordering that satisfies all m relations, output -1.
Examples
Input
4 5
2 1
1 3
2 3
4 2
4 3
Output
4
Input
3 2
1 2
3 2
Output
-1
Note
In the first sample, the robots from strongest to weakest must be (4, 2, 1, 3), which Bessie can deduce after knowing the results of the first four rap battles.
In the second sample, both (1, 3, 2) and (3, 1, 2) are possible orderings of the robots from strongest to weakest after both rap battles.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int n, m;
vector<pair<int, int>> edg;
int dl, tim, ml[N];
bool s[N];
vector<int> adj[N];
void read() {
cin >> n >> m;
edg.reserve(N);
edg.push_back({0, 0});
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
edg.push_back({u, v});
}
}
bool DFS(int v) {
bool res = false;
for (auto u : adj[v]) {
if (!ml[u]) {
dl++;
DFS(u);
dl--;
}
res = res || (dl + ml[u] + 1 == n - 1);
ml[v] = max(ml[v], ml[u] + 1);
}
return res;
}
bool can(int k) {
for (int i = 1; i <= n; i++) {
adj[i].clear();
s[i] = true;
ml[i] = 0;
}
for (int i = 1; i <= k; i++) {
adj[edg[i].first].push_back(edg[i].second);
s[edg[i].second] = 0;
}
dl = 0;
for (int i = 1; i <= n; i++)
if (s[i]) {
return DFS(i);
}
return 0;
}
int solve() {
int l = 1, r = m, ans = -1;
while (l <= r) {
int mid = (l + r) / 2;
if (can(mid)) {
ans = mid;
r = mid - 1;
} else {
l = mid + 1;
}
}
return ans;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
;
read();
cout << solve();
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
Let's define a string <x> as an opening tag, where x is any small letter of the Latin alphabet. Each opening tag matches a closing tag of the type </x>, where x is the same letter.
Tegs can be nested into each other: in this case one opening and closing tag pair is located inside another pair.
Let's define the notion of a XML-text:
* an empty string is a XML-text
* if s is a XML-text, then s'=<a>+s+</a> also is a XML-text, where a is any small Latin letter
* if s1, s2 are XML-texts, then s1+s2 also is a XML-text
You are given a XML-text (it is guaranteed that the text is valid), your task is to print in the following form:
* each tag (opening and closing) is located on a single line
* print before the tag 2 * h spaces, where h is the level of the tag's nestedness.
Input
The input data consists on the only non-empty string — the XML-text, its length does not exceed 1000 characters. It is guaranteed that the text is valid. The text contains no spaces.
Output
Print the given XML-text according to the above-given rules.
Examples
Input
<a><b><c></c></b></a>
Output
<a>
<b>
<c>
</c>
</b>
</a>
Input
<a><b></b><d><c></c></d></a>
Output
<a>
<b>
</b>
<d>
<c>
</c>
</d>
</a>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
string GetTage(const string& str) {
static int index = 0;
int left = str.find("<", index);
int right = str.find(">", index + 1);
if (left == -1 || right == -1) return "";
index = right + 1;
return str.substr(left + 1, right - left - 1);
}
int main() {
stack<string> tages;
string str;
cin >> str;
string tag;
while ((tag = GetTage(str)) != "") {
if (tag[0] != '/') {
tages.push(tag);
string space(2 * (tages.size() - 1), ' ');
cout << space << "<" << tages.top() << ">" << endl;
} else {
string space(2 * (tages.size() - 1), ' ');
cout << space << "</" << tages.top() << ">" << endl;
tages.pop();
}
}
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
You are given two arrays a_1, a_2, ... , a_n and b_1, b_2, ... , b_m. Array b is sorted in ascending order (b_i < b_{i + 1} for each i from 1 to m - 1).
You have to divide the array a into m consecutive subarrays so that, for each i from 1 to m, the minimum on the i-th subarray is equal to b_i. Note that each element belongs to exactly one subarray, and they are formed in such a way: the first several elements of a compose the first subarray, the next several elements of a compose the second subarray, and so on.
For example, if a = [12, 10, 20, 20, 25, 30] and b = [10, 20, 30] then there are two good partitions of array a:
1. [12, 10, 20], [20, 25], [30];
2. [12, 10], [20, 20, 25], [30].
You have to calculate the number of ways to divide the array a. Since the number can be pretty large print it modulo 998244353.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 2 ⋅ 10^5) — the length of arrays a and b respectively.
The second line contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9) — the array a.
The third line contains m integers b_1, b_2, ... , b_m (1 ≤ b_i ≤ 10^9; b_i < b_{i+1}) — the array b.
Output
In only line print one integer — the number of ways to divide the array a modulo 998244353.
Examples
Input
6 3
12 10 20 20 25 30
10 20 30
Output
2
Input
4 2
1 3 3 7
3 7
Output
0
Input
8 2
1 2 2 2 2 2 2 2
1 2
Output
7
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 200 * 1001, MOD = 998244353;
int n, m, a[N], b[N], res = 1;
int _mul(int a, int b) { return 1LL * a * b % MOD; }
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < m; i++) cin >> b[i];
int index = n - 1;
for (int i = m - 1; 0 <= i; i--) {
int cnt = 0;
while (a[index] > b[i] && index >= 0) index--;
if (index < 0 || a[index] != b[i]) {
cout << "0\n";
return 0;
}
while (a[index] >= b[i] && index >= 0) {
index--;
cnt++;
}
res = (i ? _mul(res, cnt) : res);
}
if (index < 0)
cout << res << "\n";
else
cout << "0\n";
}
``` |
### Prompt
Generate a cpp solution to the following problem:
Snuke has permutations (P_0,P_1,\cdots,P_{N-1}) and (Q_0,Q_1,\cdots,Q_{N-1}) of (0,1,\cdots,N-1).
Now, he will make new permutations A and B of (0,1,\cdots,N-1), under the following conditions:
* For each i (0 \leq i \leq N-1), A_i should be i or P_i.
* For each i (0 \leq i \leq N-1), B_i should be i or Q_i.
Let us define the distance of permutations A and B as the number of indices i such that A_i \neq B_i. Find the maximum possible distance of A and B.
Constraints
* 1 \leq N \leq 100000
* 0 \leq P_i \leq N-1
* P_0,P_1,\cdots,P_{N-1} are all different.
* 0 \leq Q_i \leq N-1
* Q_0,Q_1,\cdots,Q_{N-1} are all different.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
P_0 P_1 \cdots P_{N-1}
Q_0 Q_1 \cdots Q_{N-1}
Output
Print the maximum possible distance of A and B.
Examples
Input
4
2 1 3 0
0 2 3 1
Output
3
Input
10
0 4 5 3 7 8 2 1 9 6
3 8 5 6 4 0 2 1 7 9
Output
8
Input
32
22 31 30 29 7 17 16 3 14 9 19 11 2 5 10 1 25 18 15 24 20 0 12 21 27 4 26 28 8 6 23 13
22 3 2 7 17 9 16 4 14 8 19 26 28 5 10 1 25 18 15 13 11 0 12 23 21 20 29 24 27 6 30 31
Output
28
### Response
```cpp
#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
#include<algorithm>
#include<queue>
#include<cmath>
#include<cstdlib>
#define LL long long
#define LD long double
using namespace std;
const int NN=2*100000 +117;
const int MM= +117;
int read(){
int fl=1,x;char c;
for(c=getchar();(c<'0'||c>'9')&&c!='-';c=getchar());
if(c=='-'){fl=-1;c=getchar();}
for(x=0;c>='0'&&c<='9';c=getchar())
x=(x<<3)+(x<<1)+c-'0';
return x*fl;
}
void open(){
freopen("a.in","r",stdin);
//freopen("a.out","w",stdout);
}
void close(){
fclose(stdin);
fclose(stdout);
}
int m,n;
int fin,st;
int pcnt=0;
struct node{
int xt;
int to,rem;
}e[8*NN]={};
int ecnt=1;
int p[2*NN]={};
void add(int a,int b,int rem){
e[++ecnt].to=b;
e[ecnt].rem=rem;
e[ecnt].xt=p[a];
p[a]=ecnt;
}
void link(int a,int b,int rem){
add(a,b,rem);
add(b,a,0);
}
int g[2*NN]={};
int h[2*NN]={};
int q[2*NN]={};
bool bfs(){
int std=h[fin]+3;
h[st]=std;
int hd=0,tl=0;
q[tl++]=st;
while(hd!=tl){
int x=q[hd++];
if(x==fin)break;
for(int pos=p[x];pos;pos=e[pos].xt){
if(!e[pos].rem)continue;
int cur=e[pos].to;
if(h[cur]<std){
h[cur]=h[x]+1;
q[tl++]=cur;
}
}
}
return h[fin]>std;
}
int dfs(int x,int f){
if(x==fin)return f;
int res=0;
for(int &pos=g[x];pos;pos=e[pos].xt){
int cur=e[pos].to;
if(!e[pos].rem||h[cur]!=h[x]+1)continue;
int tp=dfs(cur,min(e[pos].rem,f));
if(tp){
f-=tp,res+=tp;
e[pos].rem-=tp;
e[pos^1].rem+=tp;
}
if(!f){
break;
}
}
return res;
}
int getf(){
int f=0;
while(bfs()){
for(int i=1;i<=pcnt;++i){
g[i]=p[i];
}
f+=dfs(st,1e9);
}
//cerr<<f<<endl;
return f;
}
int bel[2][NN]={};
int a[2][NN]={};
int cnt;
int main(){
//open();
n=read();
for(int i=1;i<=n;++i){
a[0][i]=read()+1;
}
for(int i=1;i<=n;++i){
a[1][i]=read()+1;
}
for(int i=1;i<=n;++i){
if(!bel[0][i]){
++cnt;
int pos=i;
while(!bel[0][pos]){
bel[0][pos]=cnt;
pos=a[0][pos];
}
}
}
for(int i=1;i<=n;++i){
if(!bel[1][i]){
++cnt;
int pos=i;
while(!bel[1][pos]){
bel[1][pos]=cnt;
pos=a[1][pos];
}
}
}
st=cnt+1;
pcnt=fin=st+1;
LL ans=0;
for(int i=1;i<=n;++i){
if(a[0][i]==a[1][i]){
if(a[0][i]==i)++ans;
else{
link(bel[0][i],bel[1][i],1);
link(bel[1][i],bel[0][i],1);
}
}
else{
if(a[0][i]==i){
link(bel[1][i],fin,1);
}
else if(a[1][i]==i){
link(st,bel[0][i],1);
}
else{
link(bel[1][i],bel[0][i],1);
}
}
}
ans+=getf();
ans=n-ans;
printf("%lld\n",ans);
close();
return 0;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
You are given a following process.
There is a platform with n columns. 1 × 1 squares are appearing one after another in some columns on this platform. If there are no squares in the column, a square will occupy the bottom row. Otherwise a square will appear at the top of the highest square of this column.
When all of the n columns have at least one square in them, the bottom row is being removed. You will receive 1 point for this, and all the squares left will fall down one row.
You task is to calculate the amount of points you will receive.
Input
The first line of input contain 2 integer numbers n and m (1 ≤ n, m ≤ 1000) — the length of the platform and the number of the squares.
The next line contain m integer numbers c_1, c_2, ..., c_m (1 ≤ c_i ≤ n) — column in which i-th square will appear.
Output
Print one integer — the amount of points you will receive.
Example
Input
3 9
1 1 2 2 2 3 1 2 3
Output
2
Note
In the sample case the answer will be equal to 2 because after the appearing of 6-th square will be removed one row (counts of the squares on the platform will look like [2~ 3~ 1], and after removing one row will be [1~ 2~ 0]).
After the appearing of 9-th square counts will be [2~ 3~ 1], and after removing one row it will look like [1~ 2~ 0].
So the answer will be equal to 2.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, ans = 0;
cin >> n >> m;
vector<int> a(n, 0);
for (int i = 0; i < m; ++i) {
int c;
cin >> c;
a[c - 1]++;
int m = 1001;
for (const auto& e : a) {
m = min(m, e);
}
ans += m;
for (int j = 0; j < n; ++j) {
a[j] -= m;
}
}
cout << ans << endl;
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
You will be given a contest schedule for D days and M queries of schedule modification. In the i-th query, given integers d_i and q_i, change the type of contest to be held on day d_i to q_i, and then output the final satisfaction at the end of day D on the updated schedule. Note that we do not revert each query. That is, the i-th query is applied to the new schedule obtained by the (i-1)-th query.
Input
Input is given from Standard Input in the form of the input of Problem A followed by the output of Problem A and the queries.
D
c_1 c_2 \cdots c_{26}
s_{1,1} s_{1,2} \cdots s_{1,26}
\vdots
s_{D,1} s_{D,2} \cdots s_{D,26}
t_1
t_2
\vdots
t_D
M
d_1 q_1
d_2 q_2
\vdots
d_M q_M
* The constraints and generation methods for the input part are the same as those for Problem A.
* For each d=1,\ldots,D, t_d is an integer generated independently and uniformly at random from {1,2,\ldots,26}.
* The number of queries M is an integer satisfying 1\leq M\leq 10^5.
* For each i=1,\ldots,M, d_i is an integer generated independently and uniformly at random from {1,2,\ldots,D}.
* For each i=1,\ldots,26, q_i is an integer satisfying 1\leq q_i\leq 26 generated uniformly at random from the 25 values that differ from the type of contest on day d_i.
Output
Let v_i be the final satisfaction at the end of day D on the schedule after applying the i-th query. Print M integers v_i to Standard Output in the following format:
v_1
v_2
\vdots
v_M
Output
Let v_i be the final satisfaction at the end of day D on the schedule after applying the i-th query. Print M integers v_i to Standard Output in the following format:
v_1
v_2
\vdots
v_M
Example
Input
5
86 90 69 51 2 96 71 47 88 34 45 46 89 34 31 38 97 84 41 80 14 4 50 83 7 82
19771 12979 18912 10432 10544 12928 13403 3047 10527 9740 8100 92 2856 14730 1396 15905 6534 4650 11469 3628 8433 2994 10899 16396 18355 11424
6674 17707 13855 16407 12232 2886 11908 1705 5000 1537 10440 10711 4917 10770 17272 15364 19277 18094 3929 3705 7169 6159 18683 15410 9092 4570
6878 4239 19925 1799 375 9563 3445 5658 19857 11401 6997 6498 19933 3848 2426 2146 19745 16880 17773 18359 3921 14172 16730 11157 5439 256
8633 15862 15303 10749 18499 7792 10317 5901 9395 11433 3514 3959 5202 19850 19469 9790 5653 784 18500 10552 17975 16615 7852 197 8471 7452
19855 17918 7990 10572 4333 438 9140 9104 12622 4985 12319 4028 19922 12132 16259 17476 2976 547 19195 19830 16285 4806 4471 9457 2864 2192
1
17
13
14
13
5
1 7
4 11
3 4
5 24
4 19
Output
72882
56634
38425
27930
42884
### Response
```cpp
//コピペ提出理解はした
#include <iostream>
#include <algorithm>
#include <vector>
#include <cmath>
#include <map>
#include <queue>
using namespace std;
#define ll long long
int main() {
int d;
cin >> d;
vector<vector<int>> s(d+1, vector<int>(26+1, 0));
vector<int> c(26+1);
for(int i = 0; i < 26; i++) cin >> c[i];
for(int i = 0; i < d; i++) {
for(int j = 0; j < 26; j++) {
cin >> s[i][j];
}
}
/////////////////
vector<int> t(d);
for(int i = 0; i < d; i++) {
t[i] = i+1;
}
for(int i = 0; i < d; i++) cin >> t[i];
///////////////
int m;
cin >> m;
vector<pair<int, int>> dq(m);
for(int i = 0; i < m; i++) {
cin >> dq[i].first >> dq[i].second;
}
vector<ll> ans(d, 0);
ll v = 0;
ll tmp = 0;
map<ll, int> mp;
priority_queue<ll> que;
int num = 0;
for(int k = 0; k < m; k++) {
tmp = t[dq[k].first-1];
t[dq[k].first-1] = dq[k].second;
vector<ll> last(26+1, 0);
for(int i = 0; i < d; i++) {
v += s[i][t[i]-1];
last[t[i]-1] = i+1;
for(int j = 0; j < 26; j++) {
v -= c[j]*((i+1)-last[j]);
}
}
cout << v << endl;
que.push(v);
mp[v] = k;
v = 0;
}
return 0;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
Qwerty the Ranger took up a government job and arrived on planet Mars. He should stay in the secret lab and conduct some experiments on bacteria that have funny and abnormal properties. The job isn't difficult, but the salary is high.
At the beginning of the first experiment there is a single bacterium in the test tube. Every second each bacterium in the test tube divides itself into k bacteria. After that some abnormal effects create b more bacteria in the test tube. Thus, if at the beginning of some second the test tube had x bacteria, then at the end of the second it will have kx + b bacteria.
The experiment showed that after n seconds there were exactly z bacteria and the experiment ended at this point.
For the second experiment Qwerty is going to sterilize the test tube and put there t bacteria. He hasn't started the experiment yet but he already wonders, how many seconds he will need to grow at least z bacteria. The ranger thinks that the bacteria will divide by the same rule as in the first experiment.
Help Qwerty and find the minimum number of seconds needed to get a tube with at least z bacteria in the second experiment.
Input
The first line contains four space-separated integers k, b, n and t (1 ≤ k, b, n, t ≤ 106) — the parameters of bacterial growth, the time Qwerty needed to grow z bacteria in the first experiment and the initial number of bacteria in the second experiment, correspondingly.
Output
Print a single number — the minimum number of seconds Qwerty needs to grow at least z bacteria in the tube.
Examples
Input
3 1 3 5
Output
2
Input
1 4 4 7
Output
3
Input
2 2 4 100
Output
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long k, b, n, t, x = 1;
cin >> k >> b >> n >> t;
while (x * k + b <= t) x = k * x + b, --n;
n = max(0LL, n);
cout << n << endl;
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
A and B are preparing themselves for programming contests.
The University where A and B study is a set of rooms connected by corridors. Overall, the University has n rooms connected by n - 1 corridors so that you can get from any room to any other one by moving along the corridors. The rooms are numbered from 1 to n.
Every day А and B write contests in some rooms of their university, and after each contest they gather together in the same room and discuss problems. A and B want the distance from the rooms where problems are discussed to the rooms where contests are written to be equal. The distance between two rooms is the number of edges on the shortest path between them.
As they write contests in new rooms every day, they asked you to help them find the number of possible rooms to discuss problems for each of the following m days.
Input
The first line contains integer n (1 ≤ n ≤ 105) — the number of rooms in the University.
The next n - 1 lines describe the corridors. The i-th of these lines (1 ≤ i ≤ n - 1) contains two integers ai and bi (1 ≤ ai, bi ≤ n), showing that the i-th corridor connects rooms ai and bi.
The next line contains integer m (1 ≤ m ≤ 105) — the number of queries.
Next m lines describe the queries. The j-th of these lines (1 ≤ j ≤ m) contains two integers xj and yj (1 ≤ xj, yj ≤ n) that means that on the j-th day A will write the contest in the room xj, B will write in the room yj.
Output
In the i-th (1 ≤ i ≤ m) line print the number of rooms that are equidistant from the rooms where A and B write contest on the i-th day.
Examples
Input
4
1 2
1 3
2 4
1
2 3
Output
1
Input
4
1 2
2 3
2 4
2
1 2
1 3
Output
0
2
Note
in the first sample there is only one room at the same distance from rooms number 2 and 3 — room number 1.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int len, n, m, size[1000000], wen[1000000], nex[1000000], hea[1000000],
fa[100005][20], dep[1000000];
void add(int x, int y) {
++len;
nex[len] = hea[x];
wen[len] = y;
hea[x] = len;
}
void dfs(int x, int y) {
size[x] = 1;
fa[x][0] = y;
dep[x] = dep[y] + 1;
for (int i = 1; i < 20; i++) fa[x][i] = fa[fa[x][i - 1]][i - 1];
for (int i = hea[x]; i; i = nex[i])
if (wen[i] != y) {
dfs(wen[i], x);
size[x] += size[wen[i]];
}
}
int LCA(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
for (int i = 19; i >= 0; i--)
if (dep[x] >= dep[y] + (1 << i)) x = fa[x][i];
if (x == y) return x;
for (int i = 19; i >= 0; i--)
if (fa[x][i] != fa[y][i]) x = fa[x][i], y = fa[y][i];
return fa[x][0];
}
int walk(int x, int y) {
for (int i = 0; i <= 19; i++)
if ((1 << i) & y) x = fa[x][i];
return x;
}
int findson(int x, int y) {
for (int i = 19; i >= 0; i--)
if (dep[x] > dep[y] + (1 << i)) x = fa[x][i];
return x;
}
int find(int x, int y) {
int lca = LCA(x, y);
if (dep[x] == dep[y])
return n - (size[findson(x, lca)] + size[findson(y, lca)]);
if ((dep[x] + dep[y] - dep[lca] * 2) % 2 == 1) return 0;
int lenth = (dep[x] + dep[y] - dep[lca] * 2) >> 1;
if (dep[x] < dep[y]) swap(x, y);
int z = walk(x, lenth);
return size[z] - size[findson(x, z)];
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
add(x, y);
add(y, x);
}
dfs(1, 0);
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
if (x != y)
printf("%d\n", find(x, y));
else
printf("%d\n", n);
}
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
One day, Snuke was given a permutation of length N, a_1, a_2, ..., a_N, from his friend.
Find the following:
<image>
Constraints
* 1 ≦ N ≦ 200,000
* (a_1, a_2, ..., a_N) is a permutation of (1, 2, ..., N).
Input
The input is given from Standard Input in the following format:
N
a_1 a_2 ... a_N
Output
Print the answer.
Note that the answer may not fit into a 32-bit integer.
Examples
Input
3
2 1 3
Output
9
Input
4
1 3 2 4
Output
19
Input
8
5 4 8 1 2 6 7 3
Output
85
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n + 1), idx(n + 1);
// for (auto &i : a) cin >> i;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
idx[a[i]] = i;
}
vector<int> l(n + 2), r(n + 2);
for (int i = 0; i <= n + 1; ++i) {
l[i] = i - 1;
r[i] = i + 1;
}
long long ans = 0;
for (long long i = n; i > 0; --i) {
long long j = idx[i];
ans += i * (j - l[j]) * (r[j] - j);
l[r[j]] = l[j];
r[l[j]] = r[j];
}
cout << ans << endl;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Today, Wet Shark is given n bishops on a 1000 by 1000 grid. Both rows and columns of the grid are numbered from 1 to 1000. Rows are numbered from top to bottom, while columns are numbered from left to right.
Wet Shark thinks that two bishops attack each other if they share the same diagonal. Note, that this is the only criteria, so two bishops may attack each other (according to Wet Shark) even if there is another bishop located between them. Now Wet Shark wants to count the number of pairs of bishops that attack each other.
Input
The first line of the input contains n (1 ≤ n ≤ 200 000) — the number of bishops.
Each of next n lines contains two space separated integers xi and yi (1 ≤ xi, yi ≤ 1000) — the number of row and the number of column where i-th bishop is positioned. It's guaranteed that no two bishops share the same position.
Output
Output one integer — the number of pairs of bishops which attack each other.
Examples
Input
5
1 1
1 5
3 3
5 1
5 5
Output
6
Input
3
1 1
2 3
3 5
Output
0
Note
In the first sample following pairs of bishops attack each other: (1, 3), (1, 5), (2, 3), (2, 4), (3, 4) and (3, 5). Pairs (1, 2), (1, 4), (2, 5) and (4, 5) do not attack each other because they do not share the same diagonal.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
unordered_map<int, int> d1, d2;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
d1[x + y]++;
d2[x - y]++;
}
long long ans = 0;
for (auto a : d1) {
long long val = a.second;
ans += (val * (val - 1)) / 2;
}
for (auto a : d2) {
long long val = a.second;
ans += (val * (val - 1)) / 2;
}
cout << ans;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
After learning a lot about space exploration, a little girl named Ana wants to change the subject.
Ana is a girl who loves palindromes (string that can be read the same backwards as forward). She has learned how to check for a given string whether it's a palindrome or not, but soon she grew tired of this problem, so she came up with a more interesting one and she needs your help to solve it:
You are given an array of strings which consist of only small letters of the alphabet. Your task is to find how many palindrome pairs are there in the array. A palindrome pair is a pair of strings such that the following condition holds: at least one permutation of the concatenation of the two strings is a palindrome. In other words, if you have two strings, let's say "aab" and "abcac", and you concatenate them into "aababcac", we have to check if there exists a permutation of this new string such that it is a palindrome (in this case there exists the permutation "aabccbaa").
Two pairs are considered different if the strings are located on different indices. The pair of strings with indices (i,j) is considered the same as the pair (j,i).
Input
The first line contains a positive integer N (1 ≤ N ≤ 100 000), representing the length of the input array.
Eacg of the next N lines contains a string (consisting of lowercase English letters from 'a' to 'z') — an element of the input array.
The total number of characters in the input array will be less than 1 000 000.
Output
Output one number, representing how many palindrome pairs there are in the array.
Examples
Input
3
aa
bb
cd
Output
1
Input
6
aab
abcac
dffe
ed
aa
aade
Output
6
Note
The first example:
1. aa + bb → abba.
The second example:
1. aab + abcac = aababcac → aabccbaa
2. aab + aa = aabaa
3. abcac + aa = abcacaa → aacbcaa
4. dffe + ed = dffeed → fdeedf
5. dffe + aade = dffeaade → adfaafde
6. ed + aade = edaade → aeddea
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
unordered_map<long long int, long long int> ma, bc;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n, i, l, len, num, ans = 0, f, s, j;
string st;
cin >> n;
for (i = 0; i < n; i++) {
cin >> st;
len = st.length();
num = 0;
for (j = 0; j < len; j++) {
num ^= (1 << (st[j] - 'a'));
}
ma[num]++;
bc[num]++;
}
unordered_map<long long int, long long int>::iterator it;
for (it = ma.begin(); it != ma.end(); it++) {
f = it->first;
s = it->second;
ans += s * (s - 1);
for (j = 0; j < 26; j++) {
long long int temp = 1 << j;
temp ^= f;
ans += bc[temp] * s;
}
}
ans /= 2;
cout << ans << endl;
return 0;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
In number world, two different numbers are friends if they have a lot in common, but also each one has unique perks.
More precisely, two different numbers a and b are friends if gcd(a,b), (a)/(gcd(a,b)), (b)/(gcd(a,b)) can form sides of a triangle.
Three numbers a, b and c can form sides of a triangle if a + b > c, b + c > a and c + a > b.
In a group of numbers, a number is lonely if it doesn't have any friends in that group.
Given a group of numbers containing all numbers from 1, 2, 3, ..., n, how many numbers in that group are lonely?
Input
The first line contains a single integer t (1 ≤ t ≤ 10^6) - number of test cases.
On next line there are t numbers, n_i (1 ≤ n_i ≤ 10^6) - meaning that in case i you should solve for numbers 1, 2, 3, ..., n_i.
Output
For each test case, print the answer on separate lines: number of lonely numbers in group 1, 2, 3, ..., n_i.
Example
Input
3
1 5 10
Output
1
3
3
Note
For first test case, 1 is the only number and therefore lonely.
For second test case where n=5, numbers 1, 3 and 5 are lonely.
For third test case where n=10, numbers 1, 5 and 7 are lonely.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long M = (1e9 + 7);
template <class A = int, class B = int, class C = int>
struct tri {
A a;
B b;
C c;
tri(const A& a, const B& b, const C& c) : a(a), b(b), c(c) {}
};
template <class T>
ostream& operator<<(ostream& o, const vector<T>& vec) {
o << "[ ";
for (const auto& v : vec) {
o << v << ' ';
}
o << "]";
return o;
}
int main() {
vector<bool> isPrime(1e6 + 1, true);
vector<int> s(1e6 + 1);
for (int i = 2; i <= 1e6; i++) {
if (isPrime[i]) {
for (int j = i + i; j < isPrime.size(); j += i) {
isPrime[j] = false;
}
}
s[i] = s[i - 1] + isPrime[i];
}
int t;
cin >> t;
while (t--) {
int n;
scanf("%d", &n);
cout << s[n] - s[sqrt(n)] + 1 << '\n';
}
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
You are going to eat X red apples and Y green apples.
You have A red apples of deliciousness p_1,p_2, \dots, p_A, B green apples of deliciousness q_1,q_2, \dots, q_B, and C colorless apples of deliciousness r_1,r_2, \dots, r_C.
Before eating a colorless apple, you can paint it red or green, and it will count as a red or green apple, respectively.
From the apples above, you will choose the apples to eat while making the sum of the deliciousness of the eaten apples as large as possible.
Find the maximum possible sum of the deliciousness of the eaten apples that can be achieved when optimally coloring zero or more colorless apples.
Constraints
* 1 \leq X \leq A \leq 10^5
* 1 \leq Y \leq B \leq 10^5
* 1 \leq C \leq 10^5
* 1 \leq p_i \leq 10^9
* 1 \leq q_i \leq 10^9
* 1 \leq r_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
X Y A B C
p_1 p_2 ... p_A
q_1 q_2 ... q_B
r_1 r_2 ... r_C
Output
Print the maximum possible sum of the deliciousness of the eaten apples.
Examples
Input
1 2 2 2 1
2 4
5 1
3
Output
12
Input
2 2 2 2 2
8 6
9 1
2 1
Output
25
Input
2 2 4 4 4
11 12 13 14
21 22 23 24
1 2 3 4
Output
74
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main()
{int X, Y, A, B, C; cin >> X >> Y >> A >> B >> C;
vector<int> ps(A), qs(B), rs(C), as; for (auto xs : {&ps, &qs, &rs}) {for (auto &b: *xs) cin >> b; sort((*xs).rbegin(), (*xs).rend());}
for (int i = 0; i < X; ++i) as.push_back(ps[i]);
for (int i = 0; i < Y; ++i) as.push_back(qs[i]);
for (auto r : rs) as.push_back(r);
sort(as.rbegin(), as.rend());
auto ans = 0LL; for (int i = 0; i < X + Y; ++i) ans += as[i];
cout << ans << endl;}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
There is a circle with a circumference of L. Each point on the circumference has a coordinate value, which represents the arc length from a certain reference point clockwise to the point. On this circumference, there are N ants. These ants are numbered 1 through N in order of increasing coordinate, and ant i is at coordinate X_i.
The N ants have just started walking. For each ant i, you are given the initial direction W_i. Ant i is initially walking clockwise if W_i is 1; counterclockwise if W_i is 2. Every ant walks at a constant speed of 1 per second. Sometimes, two ants bump into each other. Each of these two ants will then turn around and start walking in the opposite direction.
For each ant, find its position after T seconds.
Constraints
* All input values are integers.
* 1 \leq N \leq 10^5
* 1 \leq L \leq 10^9
* 1 \leq T \leq 10^9
* 0 \leq X_1 < X_2 < ... < X_N \leq L - 1
* 1 \leq W_i \leq 2
Input
The input is given from Standard Input in the following format:
N L T
X_1 W_1
X_2 W_2
:
X_N W_N
Output
Print N lines. The i-th line should contain the coordinate of ant i after T seconds. Here, each coordinate must be between 0 and L-1, inclusive.
Examples
Input
3 8 3
0 1
3 2
6 1
Output
1
3
0
Input
4 20 9
7 2
9 1
12 1
18 1
Output
7
18
18
1
### Response
```cpp
#include <iostream>
#include <algorithm>
using namespace std;
int main(){
int N, L, T;
int X[100000], W[100000], ans[100000];
int cnt = 0;
cin >> N >> L >> T;
for(int i = 0; i < N; i++){
cin >> X[i] >> W[i];
if(W[i] == 1){
if(T >= (L-X[i])){
cnt -= (1+(T-(L-X[i]))/L);
}
X[i] = (X[i]+T)%L;
}else{
if(T > X[i]){
cnt += (1+(T-X[i]-1)/L);
}
X[i] = ((X[i]-T)%L+L)%L;
}
}
cnt = ((cnt%N)+N)%N;
//cout << cnt << endl;
sort(X, X+N);
for(int i = 0; i < N; i++){
ans[i] = X[(i-cnt+N)%N];
}
for(int i = 0; i < N; i++){
cout << ans[i] << '\n';
}
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Vasya had two arrays consisting of non-negative integers: a of size n and b of size m. Vasya chose a positive integer k and created an n × m matrix v using the following formula:
<image>
Vasya wrote down matrix v on a piece of paper and put it in the table.
A year later Vasya was cleaning his table when he found a piece of paper containing an n × m matrix w. He remembered making a matrix one day by the rules given above but he was not sure if he had found the paper with the matrix v from those days. Your task is to find out if the matrix w that you've found could have been obtained by following these rules and if it could, then for what numbers k, a1, a2, ..., an, b1, b2, ..., bm it is possible.
Input
The first line contains integers n and m (1 ≤ n, m ≤ 100), separated by a space — the number of rows and columns in the found matrix, respectively.
The i-th of the following lines contains numbers wi, 1, wi, 2, ..., wi, m (0 ≤ wi, j ≤ 109), separated by spaces — the elements of the i-th row of matrix w.
Output
If the matrix w could not have been obtained in the manner described above, print "NO" (without quotes) in the single line of output.
Otherwise, print four lines.
In the first line print "YES" (without quotes).
In the second line print an integer k (1 ≤ k ≤ 1018). Note that each element of table w should be in range between 0 and k - 1 inclusively.
In the third line print n integers a1, a2, ..., an (0 ≤ ai ≤ 1018), separated by spaces.
In the fourth line print m integers b1, b2, ..., bm (0 ≤ bi ≤ 1018), separated by spaces.
Examples
Input
2 3
1 2 3
2 3 4
Output
YES
1000000007
0 1
1 2 3
Input
2 2
1 2
2 0
Output
YES
3
0 1
1 2
Input
2 2
1 2
2 1
Output
NO
Note
By <image> we denote the remainder of integer division of b by c.
It is guaranteed that if there exists some set of numbers k, a1, ..., an, b1, ..., bm, that you could use to make matrix w, then there also exists a set of numbers that meets the limits 1 ≤ k ≤ 1018, 1 ≤ ai ≤ 1018, 1 ≤ bi ≤ 1018 in the output format. In other words, these upper bounds are introduced only for checking convenience purposes.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 7;
int gcd(int a, int b) {
if (a < b) {
swap(a, b);
}
while (b) {
a %= b;
swap(a, b);
}
return a;
}
int main() {
int n, m;
cin >> n >> m;
vector<vector<int> > v(n, vector<int>(m));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cin >> v[i][j];
}
}
int k = 0;
for (int i = 1; i < n; ++i) {
vector<int> d;
for (int j = 0; j < m; ++j) {
d.push_back(v[i][j] - v[0][j]);
}
sort((d).begin(), (d).end());
d.resize(unique((d).begin(), (d).end()) - d.begin());
for (int q = 0; q < static_cast<int>((d).size()); ++q) {
for (int w = q + 1; w < static_cast<int>((d).size()); ++w) {
k = gcd(k, abs(d[q] - d[w]));
}
}
}
if (k == 0) {
k = inf;
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (v[i][j] >= k) {
cout << "NO\n";
return 0;
}
}
}
cout << "YES\n" << k << "\n";
vector<int> a(n), b(m);
a[0] = 0;
for (int j = 0; j < m; ++j) {
b[j] = v[0][j];
}
for (int i = 1; i < n; ++i) {
a[i] = v[i][0] - b[0];
if (a[i] < 0) {
a[i] += k;
}
}
for (int i = 0; i < n; ++i) {
cout << a[i] << " ";
}
cout << "\n";
for (int j = 0; j < m; ++j) {
cout << b[j] << " ";
}
cout << "\n";
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
Gerald got tired of playing board games with the usual six-sided die, and he bought a toy called Randomizer. It functions as follows.
A Randomizer has its own coordinate plane on which a strictly convex polygon is painted, the polygon is called a basic polygon. If you shake a Randomizer, it draws some nondegenerate (i.e. having a non-zero area) convex polygon with vertices at some vertices of the basic polygon. The result of the roll (more precisely, the result of the shaking) is considered to be the number of points with integer coordinates, which were strictly inside (the points on the border are not considered) the selected polygon. Now Gerald is wondering: what is the expected result of shaking the Randomizer?
During the shaking the Randomizer considers all the possible non-degenerate convex polygons with vertices at the vertices of the basic polygon. Let's assume that there are k versions of the polygons. Then the Randomizer chooses each of them with probability <image>.
Input
The first line of the input contains a single integer n (3 ≤ n ≤ 100 000) — the number of vertices of the basic polygon.
Next n lines contain the coordinates of the vertices of the basic polygon. The i-th of these lines contain two integers xi and yi ( - 109 ≤ xi, yi ≤ 109) — the coordinates of the i-th vertex of the polygon. The vertices are given in the counter-clockwise order.
Output
Print the sought expected value with absolute or relative error at most 10 - 9.
Examples
Input
4
0 0
2 0
2 2
0 2
Output
0.2
Input
5
0 0
2 0
2 2
1 3
0 2
Output
0.8125
Note
A polygon is called strictly convex if it is convex and no its vertices lie on the same line.
Let's assume that a random variable takes values x1, ..., xn with probabilities p1, ..., pn, correspondingly. Then the expected value of this variable equals to <image>.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200000 + 10;
int n;
long long area, cnt;
double fac[200], ans, calc;
struct Point {
long long x, y;
Point() {}
Point(long long x, long long y) : x(x), y(y) {}
Point operator-(const Point& tmp) const {
return Point(x - tmp.x, y - tmp.y);
}
} p[maxn];
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
long long gcd(long long x, long long y) { return y == 0 ? x : gcd(y, x % y); }
long long cross(Point A, Point B) { return A.x * B.y - A.y * B.x; }
int main() {
if (fopen("D.in", "r") != NULL) {
freopen("D.in", "r", stdin);
freopen("D.out", "w", stdout);
}
n = read();
for (int i = 0; i < n; i++) p[i].x = read(), p[i].y = read();
fac[0] = 1;
for (int i = 1; i <= 100; i++) fac[i] = fac[i - 1] * 2;
if (n <= 100) calc = fac[n] - 1 - n - n * (n - 1) / 2;
for (int i = 0; i < n; i++)
cnt += gcd(abs(p[i].x - p[(i + 1) % n].x), abs(p[i].y - p[(i + 1) % n].y));
for (int i = 1; i < n - 1; i++) area += cross(p[i] - p[0], p[i + 1] - p[0]);
ans = (area - cnt) / 2 + 1;
for (int i = 0; i < n; i++) {
area = 0,
cnt =
gcd(abs(p[i].x - p[(i + 1) % n].x), abs(p[i].y - p[(i + 1) % n].y)) + 1;
for (int k = 2, j; k <= 60; k++) {
j = (i + k) % n;
if ((j + 1) % n == i) break;
cnt += gcd(abs(p[j].x - p[(j - 1 + n) % n].x),
abs(p[j].y - p[(j - 1 + n) % n].y));
area += cross(p[(j + n - 1) % n] - p[i], p[j] - p[i]);
long long tmp = gcd(abs(p[j].x - p[i].x), abs(p[j].y - p[i].y)) - 1;
long long s = (area - (cnt + tmp)) / 2 + 1;
if (n <= 100)
ans -= (double)(tmp + s) * (fac[n - k - 1] - 1) / calc;
else
ans -= (double)(tmp + s) * (1.0 / fac[k + 1]);
}
}
printf("%.12lf\n", ans);
return 0;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
Mr. Kitayuta has just bought an undirected graph with n vertices and m edges. The vertices of the graph are numbered from 1 to n. Each edge, namely edge i, has a color ci, connecting vertex ai and bi.
Mr. Kitayuta wants you to process the following q queries.
In the i-th query, he gives you two integers - ui and vi.
Find the number of the colors that satisfy the following condition: the edges of that color connect vertex ui and vertex vi directly or indirectly.
Input
The first line of the input contains space-separated two integers - n and m(2 ≤ n ≤ 105, 1 ≤ m ≤ 105), denoting the number of the vertices and the number of the edges, respectively.
The next m lines contain space-separated three integers - ai, bi(1 ≤ ai < bi ≤ n) and ci(1 ≤ ci ≤ m). Note that there can be multiple edges between two vertices. However, there are no multiple edges of the same color between two vertices, that is, if i ≠ j, (ai, bi, ci) ≠ (aj, bj, cj).
The next line contains a integer- q(1 ≤ q ≤ 105), denoting the number of the queries.
Then follows q lines, containing space-separated two integers - ui and vi(1 ≤ ui, vi ≤ n). It is guaranteed that ui ≠ vi.
Output
For each query, print the answer in a separate line.
Examples
Input
4 5
1 2 1
1 2 2
2 3 1
2 3 3
2 4 3
3
1 2
3 4
1 4
Output
2
1
0
Input
5 7
1 5 1
2 5 1
3 5 1
4 5 1
1 2 2
2 3 2
3 4 2
5
1 5
5 1
2 5
1 5
1 4
Output
1
1
1
1
2
Note
Let's consider the first sample.
<image> The figure above shows the first sample.
* Vertex 1 and vertex 2 are connected by color 1 and 2.
* Vertex 3 and vertex 4 are connected by color 3.
* Vertex 1 and vertex 4 are not connected by any single color.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int visited[101];
int bfs(vector<int> Adjlist[101][101], int a, int b, int c) {
int i, v;
deque<int> Q;
memset(visited, 0, sizeof(visited));
Q.push_back(a);
while (!Q.empty()) {
v = Q.front();
visited[v] = 1;
Q.pop_front();
for (i = 0; i < Adjlist[v][c].size(); i++) {
if (Adjlist[v][c][i] == b) return 1;
if (!visited[Adjlist[v][c][i]]) Q.push_back(Adjlist[v][c][i]);
}
}
return 0;
}
int main() {
int n, m, a, b, c, ans, i, q, j;
scanf("%d%d", &n, &m);
vector<int> Adjlist[101][101];
for (i = 0; i < m; i++) {
scanf("%d%d%d", &a, &b, &c);
Adjlist[b][c].push_back(a);
Adjlist[a][c].push_back(b);
}
scanf("%d", &q);
for (i = 0; i < q; i++) {
scanf("%d%d", &a, &b);
ans = 0;
for (j = 0; j < m; j++) {
ans += bfs(Adjlist, a, b, j + 1);
}
printf("%d\n", ans);
}
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
One particularly well-known fact about zombies is that they move and think terribly slowly. While we still don't know why their movements are so sluggish, the problem of laggy thinking has been recently resolved. It turns out that the reason is not (as previously suspected) any kind of brain defect – it's the opposite! Independent researchers confirmed that the nervous system of a zombie is highly complicated – it consists of n brains (much like a cow has several stomachs). They are interconnected by brain connectors, which are veins capable of transmitting thoughts between brains. There are two important properties such a brain network should have to function properly:
1. It should be possible to exchange thoughts between any two pairs of brains (perhaps indirectly, through other brains).
2. There should be no redundant brain connectors, that is, removing any brain connector would make property 1 false.
If both properties are satisfied, we say that the nervous system is valid. Unfortunately (?), if the system is not valid, the zombie stops thinking and becomes (even more) dead. Your task is to analyze a given nervous system of a zombie and find out whether it is valid.
Input
The first line of the input contains two space-separated integers n and m (1 ≤ n, m ≤ 1000) denoting the number of brains (which are conveniently numbered from 1 to n) and the number of brain connectors in the nervous system, respectively. In the next m lines, descriptions of brain connectors follow. Every connector is given as a pair of brains a b it connects (1 ≤ a, b ≤ n, a ≠ b).
Output
The output consists of one line, containing either yes or no depending on whether the nervous system is valid.
Examples
Input
4 4
1 2
2 3
3 1
4 1
Output
no
Input
6 5
1 2
2 3
3 4
4 5
3 6
Output
yes
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<int> brains[1001], vis(1001);
int cc = 0;
void dfs(int node) {
vis[node] = 1;
for (int brain : brains[node]) {
if (!vis[brain]) dfs(brain);
}
}
void solve() {
int n, m;
cin >> n >> m;
int i;
for (i = 0; 0 < m ? i < m : i > m; 0 < m ? i++ : i--) {
int a, b;
cin >> a >> b;
brains[a].push_back(b);
brains[b].push_back(a);
}
if (m != n - 1) {
cout << "no\n";
return;
}
for (i = 1; 1 < n + 1 ? i < n + 1 : i > n + 1; 1 < n + 1 ? i++ : i--) {
if (!vis[i]) dfs(i), cc++;
}
cout << (cc == 1 ? "yes\n" : "no\n");
}
int main(void) {
cin.tie(0);
ios_base::sync_with_stdio(false);
int t = 1;
while (t--) solve();
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
Let's define a string <x> as an opening tag, where x is any small letter of the Latin alphabet. Each opening tag matches a closing tag of the type </x>, where x is the same letter.
Tegs can be nested into each other: in this case one opening and closing tag pair is located inside another pair.
Let's define the notion of a XML-text:
* an empty string is a XML-text
* if s is a XML-text, then s'=<a>+s+</a> also is a XML-text, where a is any small Latin letter
* if s1, s2 are XML-texts, then s1+s2 also is a XML-text
You are given a XML-text (it is guaranteed that the text is valid), your task is to print in the following form:
* each tag (opening and closing) is located on a single line
* print before the tag 2 * h spaces, where h is the level of the tag's nestedness.
Input
The input data consists on the only non-empty string — the XML-text, its length does not exceed 1000 characters. It is guaranteed that the text is valid. The text contains no spaces.
Output
Print the given XML-text according to the above-given rules.
Examples
Input
<a><b><c></c></b></a>
Output
<a>
<b>
<c>
</c>
</b>
</a>
Input
<a><b></b><d><c></c></d></a>
Output
<a>
<b>
</b>
<d>
<c>
</c>
</d>
</a>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin >> s;
int nest = 0, n;
n = s.length();
for (int i = 0; i < n; i++) {
string s1 = "";
while (s[i] != '>') s1 += s[i], i++;
s1 += s[i];
int k = 0;
if (s1[1] == '/') nest--;
while (k < 2 * nest) cout << " ", k++;
cout << s1 << endl;
if (s1[1] != '/') nest++;
}
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main() {
int n, m, l;
cin >> n >> m;
l = ((n - m) + 19 * m) * pow(2, m) * 100;
cout << l;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
The statement of this problem is the same as the statement of problem C2. 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 even integer n (2 ≤ n ≤ 200). 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
2
4
200
Output
1.000000000
2.414213562
127.321336469
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0, flag = 0;
char ch = getchar();
if (ch == '-') flag = 1;
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9') x *= 10, x += ch - '0', ch = getchar();
if (flag) return -x;
return x;
}
int main() {
int test;
cin >> test;
while (test--) {
double i;
double sum = 0;
int n;
cin >> n;
double t = tan(acos(-1) / (2 * n));
printf("%.9lf\n", 1 / t);
}
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
Consider the following experiment. You have a deck of m cards, and exactly one card is a joker. n times, you do the following: shuffle the deck, take the top card of the deck, look at it and return it into the deck.
Let x be the number of times you have taken the joker out of the deck during this experiment. Assuming that every time you shuffle the deck, all m! possible permutations of cards are equiprobable, what is the expected value of x^k? Print the answer modulo 998244353.
Input
The only line contains three integers n, m and k (1 ≤ n, m < 998244353, 1 ≤ k ≤ 5000).
Output
Print one integer — the expected value of x^k, taken modulo 998244353 (the answer can always be represented as an irreducible fraction a/b, where b mod 998244353 ≠ 0; you have to print a ⋅ b^{-1} mod 998244353).
Examples
Input
1 1 1
Output
1
Input
1 1 5000
Output
1
Input
2 2 2
Output
499122178
Input
998244352 1337 5000
Output
326459680
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353, MAXN = 5050;
int qpow(int x, int y) {
if (y < 0) return qpow(qpow(x, -y), mod - 2);
int ret = 1;
while (y) {
if (y & 1) ret = 1ll * ret * x % mod;
x = 1ll * x * x % mod;
y >>= 1;
}
return ret;
}
int s2[MAXN][MAXN], rua[MAXN], p2[MAXN];
int n, m, t;
int main() {
scanf("%d%d%d", &n, &m, &t);
int i, j;
rua[0] = 1;
s2[0][0] = 1;
p2[0] = qpow(2, n);
for (i = 1; i <= t; i++)
rua[i] = 1ll * rua[i - 1] * (n - i + 1) % mod, p2[i] = qpow(m, n - i);
for (i = 1; i <= t; i++)
for (j = 1; j <= i; j++)
s2[i][j] = (1ll * j * s2[i - 1][j] % mod + s2[i - 1][j - 1]) % mod;
int ans = 0;
for (i = 0; i <= t; i++)
ans = (ans + 1ll * s2[t][i] * rua[i] % mod * p2[i] % mod) % mod;
ans = 1ll * ans * qpow(m, -n) % mod;
printf("%d\n", (ans + mod) % mod);
return 0;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
Mishka received a gift of multicolored pencils for his birthday! Unfortunately he lives in a monochrome world, where everything is of the same color and only saturation differs. This pack can be represented as a sequence a1, a2, ..., an of n integer numbers — saturation of the color of each pencil. Now Mishka wants to put all the mess in the pack in order. He has an infinite number of empty boxes to do this. He would like to fill some boxes in such a way that:
* Each pencil belongs to exactly one box;
* Each non-empty box has at least k pencils in it;
* If pencils i and j belong to the same box, then |ai - aj| ≤ d, where |x| means absolute value of x. Note that the opposite is optional, there can be pencils i and j such that |ai - aj| ≤ d and they belong to different boxes.
Help Mishka to determine if it's possible to distribute all the pencils into boxes. Print "YES" if there exists such a distribution. Otherwise print "NO".
Input
The first line contains three integer numbers n, k and d (1 ≤ k ≤ n ≤ 5·105, 0 ≤ d ≤ 109) — the number of pencils, minimal size of any non-empty box and maximal difference in saturation between any pair of pencils in the same box, respectively.
The second line contains n integer numbers a1, a2, ..., an (1 ≤ ai ≤ 109) — saturation of color of each pencil.
Output
Print "YES" if it's possible to distribute all the pencils into boxes and satisfy all the conditions. Otherwise print "NO".
Examples
Input
6 3 10
7 2 7 7 4 2
Output
YES
Input
6 2 3
4 5 3 13 4 10
Output
YES
Input
3 2 5
10 16 22
Output
NO
Note
In the first example it is possible to distribute pencils into 2 boxes with 3 pencils in each with any distribution. And you also can put all the pencils into the same box, difference of any pair in it won't exceed 10.
In the second example you can split pencils of saturations [4, 5, 3, 4] into 2 boxes of size 2 and put the remaining ones into another box.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long N = 5e5 + 10;
const long long M = 59049 + 10;
const long long inf = 1e16 + 7;
const long long Mod = 1e9 + 7;
const double eps = 1e-6;
int T;
int n, k, d;
int a[N];
int sum[N];
int f[N];
int main() {
scanf("%d%d%d", &n, &k, &d);
for (int i = 1; i <= n; ++i) scanf("%d", a + i);
sort(a + 1, a + n + 1);
int l = 1;
sum[1] = 1;
for (int i = 1; i <= n; ++i) {
while (a[l] + d < a[i]) l++;
if (i - k + 1 >= l) {
if (sum[i - k + 1] - sum[l - 1] >= 1) f[i + 1] = 1;
}
sum[i + 1] = sum[i] + f[i + 1];
}
if (f[n + 1])
puts("YES");
else
puts("NO");
return 0;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
Polycarp is writing the prototype of a graphic editor. He has already made up his mind that the basic image transformations in his editor will be: rotate the image 90 degrees clockwise, flip the image horizontally (symmetry relative to the vertical line, that is, the right part of the image moves to the left, and vice versa) and zooming on the image. He is sure that that there is a large number of transformations that can be expressed through these three.
He has recently stopped implementing all three transformations for monochrome images. To test this feature, he asked you to write a code that will consecutively perform three actions with a monochrome image: first it will rotate the image 90 degrees clockwise, then it will flip the image horizontally and finally, it will zoom in twice on the image (that is, it will double all the linear sizes).
Implement this feature to help Polycarp test his editor.
Input
The first line contains two integers, w and h (1 ≤ w, h ≤ 100) — the width and height of an image in pixels. The picture is given in h lines, each line contains w characters — each character encodes the color of the corresponding pixel of the image. The line consists only of characters "." and "*", as the image is monochrome.
Output
Print 2w lines, each containing 2h characters — the result of consecutive implementing of the three transformations, described above.
Examples
Input
3 2
.*.
.*.
Output
....
....
****
****
....
....
Input
9 20
**.......
****.....
******...
*******..
..******.
....****.
......***
*.....***
*********
*********
*********
*********
....**...
...****..
..******.
.********
****..***
***...***
**.....**
*.......*
Output
********......**********........********
********......**********........********
********........********......********..
********........********......********..
..********......********....********....
..********......********....********....
..********......********..********......
..********......********..********......
....********....****************........
....********....****************........
....********....****************........
....********....****************........
......******************..**********....
......******************..**********....
........****************....**********..
........****************....**********..
............************......**********
............************......**********
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m, i, j, a, b;
char ara[200][200];
cin >> a >> b;
m = a;
n = b;
for (i = 0; i < n; i++) {
for (j = 0; j < m * 2; j++) {
cin >> ara[i][j];
ara[i][j + 1] = ara[i][j];
j++;
}
}
for (i = 0; i < 2 * m; i++) {
for (j = 0; j < n; j++) {
cout << ara[j][i];
cout << ara[j][i];
}
cout << endl;
}
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
Your friend has n cards.
You know that each card has a lowercase English letter on one side and a digit on the other.
Currently, your friend has laid out the cards on a table so only one side of each card is visible.
You would like to know if the following statement is true for cards that your friend owns: "If a card has a vowel on one side, then it has an even digit on the other side." More specifically, a vowel is one of 'a', 'e', 'i', 'o' or 'u', and even digit is one of '0', '2', '4', '6' or '8'.
For example, if a card has 'a' on one side, and '6' on the other side, then this statement is true for it. Also, the statement is true, for example, for a card with 'b' and '4', and for a card with 'b' and '3' (since the letter is not a vowel). The statement is false, for example, for card with 'e' and '5'. You are interested if the statement is true for all cards. In particular, if no card has a vowel, the statement is true.
To determine this, you can flip over some cards to reveal the other side. You would like to know what is the minimum number of cards you need to flip in the worst case in order to verify that the statement is true.
Input
The first and only line of input will contain a string s (1 ≤ |s| ≤ 50), denoting the sides of the cards that you can see on the table currently. Each character of s is either a lowercase English letter or a digit.
Output
Print a single integer, the minimum number of cards you must turn over to verify your claim.
Examples
Input
ee
Output
2
Input
z
Output
0
Input
0ay1
Output
2
Note
In the first sample, we must turn over both cards. Note that even though both cards have the same letter, they could possibly have different numbers on the other side.
In the second sample, we don't need to turn over any cards. The statement is vacuously true, since you know your friend has no cards with a vowel on them.
In the third sample, we need to flip the second and fourth cards.
### Response
```cpp
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
#pragma comment(linker, "/STACK:336777216")
using namespace std;
const int N = 1000 * 1000 + 100;
const long long MOD = 1e9 + 7;
const long long INC = INT_MAX;
const long long EPS = LLONG_MAX;
const long long INF = ULLONG_MAX;
long long minim = INF;
long long maxim = -INF;
long long cnt = 0, ans = 0;
vector<int> dp(N);
bool u = false, U[N];
int a[N], b[N], c[N];
int A[N / 1000][N / 1000];
string s, t;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string cur = "aeiou";
cin >> s;
for (auto i : s) {
for (auto j : cur)
if (j == i) {
++cnt;
continue;
}
if (isdigit(i)) {
if (i % 2 == 1) ++cnt;
}
}
cout << cnt << endl;
return 0;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
Masha lives in a multi-storey building, where floors are numbered with positive integers. Two floors are called adjacent if their numbers differ by one. Masha decided to visit Egor. Masha lives on the floor x, Egor on the floor y (not on the same floor with Masha).
The house has a staircase and an elevator. If Masha uses the stairs, it takes t_1 seconds for her to walk between adjacent floors (in each direction). The elevator passes between adjacent floors (in each way) in t_2 seconds. The elevator moves with doors closed. The elevator spends t_3 seconds to open or close the doors. We can assume that time is not spent on any action except moving between adjacent floors and waiting for the doors to open or close. If Masha uses the elevator, it immediately goes directly to the desired floor.
Coming out of the apartment on her floor, Masha noticed that the elevator is now on the floor z and has closed doors. Now she has to choose whether to use the stairs or use the elevator.
If the time that Masha needs to get to the Egor's floor by the stairs is strictly less than the time it will take her using the elevator, then she will use the stairs, otherwise she will choose the elevator.
Help Mary to understand whether to use the elevator or the stairs.
Input
The only line contains six integers x, y, z, t_1, t_2, t_3 (1 ≤ x, y, z, t_1, t_2, t_3 ≤ 1000) — the floor Masha is at, the floor Masha wants to get to, the floor the elevator is located on, the time it takes Masha to pass between two floors by stairs, the time it takes the elevator to pass between two floors and the time it takes for the elevator to close or open the doors.
It is guaranteed that x ≠ y.
Output
If the time it will take to use the elevator is not greater than the time it will take to use the stairs, print «YES» (without quotes), otherwise print «NO> (without quotes).
You can print each letter in any case (upper or lower).
Examples
Input
5 1 4 4 2 1
Output
YES
Input
1 6 6 2 1 1
Output
NO
Input
4 1 7 4 1 2
Output
YES
Note
In the first example:
If Masha goes by the stairs, the time she spends is 4 ⋅ 4 = 16, because she has to go 4 times between adjacent floors and each time she spends 4 seconds.
If she chooses the elevator, she will have to wait 2 seconds while the elevator leaves the 4-th floor and goes to the 5-th. After that the doors will be opening for another 1 second. Then Masha will enter the elevator, and she will have to wait for 1 second for the doors closing. Next, the elevator will spend 4 ⋅ 2 = 8 seconds going from the 5-th floor to the 1-st, because the elevator has to pass 4 times between adjacent floors and spends 2 seconds each time. And finally, it will take another 1 second before the doors are open and Masha can come out.
Thus, all the way by elevator will take 2 + 1 + 1 + 8 + 1 = 13 seconds, which is less than 16 seconds, so Masha has to choose the elevator.
In the second example, it is more profitable for Masha to use the stairs, because it will take 13 seconds to use the elevator, that is more than the 10 seconds it will takes to go by foot.
In the third example, the time it takes to use the elevator is equal to the time it takes to walk up by the stairs, and is equal to 12 seconds. That means Masha will take the elevator.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
inline int My_abs(int x) { return x < 0 ? -x : x; }
int main() {
int x, y, z, t1, t2, t3;
int a, b;
scanf("%d%d%d%d%d%d", &x, &y, &z, &t1, &t2, &t3);
a = t1 * My_abs(y - x);
b = t2 * (My_abs(x - z) + My_abs(x - y)) + 3 * t3;
if (b <= a)
printf("YES");
else
printf("NO");
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
Given a tree with n (1 ≤ n ≤ 200,000) nodes and a list of q (1 ≤ q ≤ 100,000) queries, process the queries in order and output a value for each output query. The given tree is connected and each node on the tree has a weight wi (-10,000 ≤ wi ≤ 10,000).
Each query consists of a number ti (ti = 1, 2), which indicates the type of the query , and three numbers ai, bi and ci (1 ≤ ai, bi ≤ n, -10,000 ≤ ci ≤ 10,000). Depending on the query type, process one of the followings:
* (ti = 1: modification query) Change the weights of all nodes on the shortest path between ai and bi (both inclusive) to ci.
* (ti = 2: output query) First, create a list of weights on the shortest path between ai and bi (both inclusive) in order. After that, output the maximum sum of a non-empty continuous subsequence of the weights on the list. ci is ignored for output queries.
Input
The first line contains two integers n and q. On the second line, there are n integers which indicate w1, w2, ... , wn.
Each of the following n - 1 lines consists of two integers si and ei (1 ≤ si, ei ≤ n), which means that there is an edge between si and ei.
Finally the following q lines give the list of queries, each of which contains four integers in the format described above. Queries must be processed one by one from top to bottom.
Output
For each output query, output the maximum sum in one line.
Examples
Input
3 4
1 2 3
1 2
2 3
2 1 3 0
1 2 2 -4
2 1 3 0
2 2 2 0
Output
6
3
-4
Input
7 5
-8 5 5 5 5 5 5
1 2
2 3
1 4
4 5
1 6
6 7
2 3 7 0
2 5 2 0
2 4 3 0
1 1 1 -1
2 3 7 0
Output
12
10
10
19
Input
21 30
10 0 -10 -8 5 -5 -4 -3 1 -2 8 -1 -7 2 7 6 -9 -6 3 4 9
10 3
3 2
3 12
12 4
4 13
4 9
10 21
21 1
1 11
11 14
1 15
10 6
6 17
6 16
6 5
5 18
5 19
10 7
10 8
8 20
1 1 21 -10
1 3 19 10
2 1 13 0
1 4 18 8
1 5 17 -5
2 16 7 0
1 6 16 5
1 7 15 4
2 4 20 0
1 8 14 3
1 9 13 -1
2 9 18 0
1 10 12 2
1 11 11 -8
2 21 15 0
1 12 10 1
1 13 9 7
2 6 14 0
1 14 8 -2
1 15 7 -7
2 10 2 0
1 16 6 -6
1 17 5 9
2 12 17 0
1 18 4 6
1 19 3 -3
2 11 8 0
1 20 2 -4
1 21 1 -9
2 5 19 0
Output
20
9
29
27
10
12
1
18
-2
-3
### Response
```cpp
#include <cassert>
#include <utility>
#include <vector>
template <typename ValueMonoid, typename OperatorMonoid, class Modify>
class LinkCutTree {
public:
using value_type = ValueMonoid;
using operator_type = OperatorMonoid;
private:
struct node_t {
node_t *left, *right, *par;
value_type value, sum;
operator_type lazy;
bool isroot, reversed;
node_t()
: left(nullptr), right(nullptr), par(nullptr), value(), sum(), lazy(),
isroot(1), reversed(0) {}
bool isleft() const { return par->left == this; }
void assign(const operator_type &data) { lazy = lazy + data; }
void haulL(node_t *const t) {
left = t;
if (t)
t->par = this;
}
void haulR(node_t *const t) {
right = t;
if (t)
t->par = this;
}
};
value_type reflect(const node_t *const t) const {
if (!t)
return value_type();
if (t->reversed)
return m(~t->sum, t->lazy);
return m(t->sum, t->lazy);
}
void recalc(node_t *const t) {
t->sum = reflect(t->left) + t->value + reflect(t->right);
}
void splay(node_t *const t) {
node_t *p, *pp = t, *x = t->par;
while (!t->isroot) {
if (x->left == pp)
x->left = t;
else
x->right = t;
p = t->par;
if (p->isroot) {
t->par = p->par;
std::swap(t->isroot, p->isroot);
if (p->left == t) {
p->haulL(t->right);
t->haulR(p);
}
else {
p->haulR(t->left);
t->haulL(p);
}
recalc(p);
break;
}
pp = p->par;
x = pp->par;
std::swap(t->isroot, pp->isroot);
if (t->isleft()) {
if (p->isleft()) {
pp->haulL(p->right);
p->haulR(pp);
}
else {
pp->haulR(t->left);
t->haulL(pp);
}
p->haulL(t->right);
t->haulR(p);
}
else {
if (p->isleft()) {
pp->haulL(t->right);
t->haulR(pp);
}
else {
pp->haulR(p->left);
p->haulL(pp);
}
p->haulR(t->left);
t->haulL(p);
}
recalc(pp);
recalc(p);
t->par = x;
}
}
void push(node_t *const t) {
if (t->left)
t->left->assign(t->lazy);
if (t->right)
t->right->assign(t->lazy);
t->value = m(t->value, t->lazy);
t->lazy = operator_type();
if (!t->reversed)
return;
std::swap(t->left, t->right);
if (t->left)
t->left->reversed ^= 1;
if (t->right)
t->right->reversed ^= 1;
t->value = ~t->value;
t->reversed = 0;
}
void propagate(node_t *const t) {
node_t *x = t->par, *prev = t;
while (x) {
std::swap(x->par, prev);
std::swap(x, prev);
}
while (x != t) {
std::swap(x, prev);
push(x);
std::swap(x->par, prev);
}
}
void expose(node_t *const n) {
propagate(n);
node_t *x = n, *prev = nullptr;
while (x) {
splay(x);
if (x->right)
x->right->isroot = 1;
x->right = prev;
if (prev)
prev->isroot = 0;
recalc(x);
prev = x;
x = x->par;
}
splay(n);
recalc(n);
}
using container_type = std::vector<node_t>;
public:
using size_type = typename container_type::size_type;
private:
container_type tree;
const Modify m;
void reroot(const size_type v) {
expose(&tree[v]);
tree[v].reversed ^= 1;
}
public:
explicit LinkCutTree(const size_type size, const Modify &m = Modify())
: tree(size), m(m) {}
explicit LinkCutTree(const std::vector<value_type> &a,
const Modify &m = Modify())
: tree(a.size()), m(m) {
for (size_type i = 0; i < a.size(); ++i)
tree[i].value = tree[i].sum = a[i];
}
void link(const size_type child, const size_type parent) {
assert(child < size());
assert(parent < size());
reroot(child);
tree[child].par = &tree[parent];
}
void cut(const size_type child) {
assert(child < size());
node_t *const n = &tree[child];
expose(n);
if (n->left) {
n->left->isroot = 1;
n->left->par = nullptr;
}
n->left = nullptr;
n->sum = n->value;
}
void update(const size_type u, const size_type v, const operator_type &data) {
assert(u < size());
assert(v < size());
reroot(u);
expose(&tree[v]);
tree[v].assign(data);
}
value_type path(const size_type u, const size_type v) {
assert(u < size());
assert(v < size());
reroot(u);
expose(&tree[v]);
return tree[v].sum;
}
size_type size() const noexcept { return tree.size(); }
bool empty() const noexcept { return tree.empty(); }
};
#include<algorithm>
struct Ass {
int a;
bool f;
Ass() :f(1) {}
Ass(int a) :a(a), f(0) {}
Ass operator+(const Ass &o)const {
return o.f ? *this : o;
}
};
struct Line {
int all, l, r, max, siz;
bool f;
Line() :f(1) {}
Line(int all, int l, int r, int max, int siz, bool f = 0) :
all(all), l(l), r(r), max(max), siz(siz), f(f) {}
Line operator~()const { return Line(all, r, l, max, siz, f); }
Line operator+(const Line &o)const {
if (f) return o;
if (o.f) return *this;
return Line(
all + o.all,
std::max(l, o.l > 0 ? all + o.l : all),
std::max(o.r, r > 0 ? r + o.all : o.all),
std::max(std::max(max, o.max), r + o.l),
siz + o.siz
);
}
};
struct hoge {
Line operator()(const Line &x, const Ass &y)const {
if (y.f || x.f) return x;
if (y.a > 0)
return Line(y.a*x.siz, y.a*x.siz, y.a*x.siz, y.a*x.siz, x.siz);
else
return Line(y.a*x.siz, y.a, y.a, y.a, x.siz);
}
};
#include<cstdio>
#include<vector>
int main(void) {
int nn, q;
scanf("%d %d", &nn, &q);
const int n = nn;
std::vector<Line> d;
int w;
for (int i = 0;i < n;++i) {
scanf("%d", &w);
d.emplace_back(w, w, w, w, 1);
}
LinkCutTree<Line, Ass, hoge> T(d);
int s, e;
for (int i = 1;i < n;++i) {
scanf("%d %d", &s, &e);
T.link(s-1, e-1);
}
int t, a, b;
Ass c(0);
while (q--) {
scanf("%d %d %d %d", &t, &a, &b, &c.a);
if (t == 1)
T.update(a - 1, b - 1, c);
else
printf("%d\n", T.path(a - 1, b - 1).max);
}
return 0;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
Awruk is taking part in elections in his school. It is the final round. He has only one opponent — Elodreip. The are n students in the school. Each student has exactly k votes and is obligated to use all of them. So Awruk knows that if a person gives a_i votes for Elodreip, than he will get exactly k - a_i votes from this person. Of course 0 ≤ k - a_i holds.
Awruk knows that if he loses his life is over. He has been speaking a lot with his friends and now he knows a_1, a_2, ..., a_n — how many votes for Elodreip each student wants to give. Now he wants to change the number k to win the elections. Of course he knows that bigger k means bigger chance that somebody may notice that he has changed something and then he will be disqualified.
So, Awruk knows a_1, a_2, ..., a_n — how many votes each student will give to his opponent. Help him select the smallest winning number k. In order to win, Awruk needs to get strictly more votes than Elodreip.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the number of students in the school.
The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 100) — the number of votes each student gives to Elodreip.
Output
Output the smallest integer k (k ≥ max a_i) which gives Awruk the victory. In order to win, Awruk needs to get strictly more votes than Elodreip.
Examples
Input
5
1 1 1 5 1
Output
5
Input
5
2 2 3 2 2
Output
5
Note
In the first example, Elodreip gets 1 + 1 + 1 + 5 + 1 = 9 votes. The smallest possible k is 5 (it surely can't be less due to the fourth person), and it leads to 4 + 4 + 4 + 0 + 4 = 16 votes for Awruk, which is enough to win.
In the second example, Elodreip gets 11 votes. If k = 4, Awruk gets 9 votes and loses to Elodreip.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n], mx = -1, sum = 0, sum1 = 0;
for (int i = 0; i < n; i++) {
cin >> arr[i];
mx = max(mx, arr[i]);
sum += arr[i];
}
for (int i = 0; i < n; i++) {
arr[i] = mx - arr[i];
sum1 += arr[i];
}
int ans = mx;
while (sum1 <= sum) {
ans++;
sum1 += n;
}
cout << ans << endl;
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
You've gotten an n × m sheet of squared paper. Some of its squares are painted. Let's mark the set of all painted squares as A. Set A is connected. Your task is to find the minimum number of squares that we can delete from set A to make it not connected.
A set of painted squares is called connected, if for every two squares a and b from this set there is a sequence of squares from the set, beginning in a and ending in b, such that in this sequence any square, except for the last one, shares a common side with the square that follows next in the sequence. An empty set and a set consisting of exactly one square are connected by definition.
Input
The first input line contains two space-separated integers n and m (1 ≤ n, m ≤ 50) — the sizes of the sheet of paper.
Each of the next n lines contains m characters — the description of the sheet of paper: the j-th character of the i-th line equals either "#", if the corresponding square is painted (belongs to set A), or equals "." if the corresponding square is not painted (does not belong to set A). It is guaranteed that the set of all painted squares A is connected and isn't empty.
Output
On the first line print the minimum number of squares that need to be deleted to make set A not connected. If it is impossible, print -1.
Examples
Input
5 4
####
#..#
#..#
#..#
####
Output
2
Input
5 5
#####
#...#
#####
#...#
#####
Output
2
Note
In the first sample you can delete any two squares that do not share a side. After that the set of painted squares is not connected anymore.
The note to the second sample is shown on the figure below. To the left there is a picture of the initial set of squares. To the right there is a set with deleted squares. The deleted squares are marked with crosses.
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int DIM = 55;
char arr[DIM][DIM];
bitset<DIM> mrk[DIM];
const int dx[5] = {0, -1, 0, 1, 0};
const int dy[5] = {0, 0, 1, 0, -1};
void dfs(int x, int y, int &nr) {
mrk[x][y] = 1;
nr++;
for (int d = 1; d <= 4; d++) {
int xx = x + dx[d];
int yy = y + dy[d];
if (mrk[xx][yy] == 0 && arr[xx][yy] == '#') dfs(xx, yy, nr);
}
return;
}
int main(void) {
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
int cnt = 0;
for (int i = 1; i <= n; i++) {
cin >> (arr[i] + 1);
for (int j = 1; j <= m; j++) cnt += (arr[i][j] == '#');
}
if (cnt <= 2) {
cout << -1 << endl;
return 0;
}
int mnm = 2;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (arr[i][j] == '#') {
arr[i][j] = '.';
for (int k = 1; k <= n; k++) mrk[k].reset();
int nr = 0;
for (int ii = 1; ii <= n && nr == 0; ii++) {
for (int jj = 1; jj <= m && nr == 0; jj++) {
if (arr[ii][jj] == '#') dfs(ii, jj, nr);
}
}
mnm = min(mnm, 2 - (cnt - 1 != nr));
arr[i][j] = '#';
}
}
}
cout << mnm << endl;
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
For a given sequence A = {a0, a1, ... , an-1}, find the length of the longest increasing subsequnece (LIS) in A.
An increasing subsequence of A is defined by a subsequence {ai0, ai1, ... , aik} where 0 ≤ i0 < i1 < ... < ik < n and ai0 < ai1 < ... < aik.
Constraints
* 1 ≤ n ≤ 100000
* 0 ≤ ai ≤ 109
Input
n
a0
a1
:
an-1
In the first line, an integer n is given. In the next n lines, elements of A are given.
Output
The length of the longest increasing subsequence of A.
Examples
Input
5
5
1
3
2
4
Output
3
Input
3
1
1
1
Output
1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, len = 0;
cin >> n;
int num[n], dp[n];
for(int i = 0; i < n; ++i) {
cin >> num[i];
}
dp[0] = num[0];
for(int i = 1; i < n; ++i) {
if(dp[len] < num[i]) {
dp[++len] = num[i];
} else {
*lower_bound(dp, dp + len, num[i]) = num[i];
}
}
cout << len + 1 << endl;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
Input
The first line contains a single integer n (1 ≤ n ≤ 1000) — the number of points on a plane.
Each of the next n lines contains two real coordinates xi and yi of the <image> point, specified with exactly 2 fractional digits. All coordinates are between - 1000 and 1000, inclusive.
Output
Output a single real number θ — the answer to the problem statement. The absolute or relative error of your answer should be at most 10 - 2.
Examples
Input
8
-2.14 2.06
-1.14 2.04
-2.16 1.46
-2.14 0.70
-1.42 0.40
-0.94 -0.48
-1.42 -1.28
-2.16 -1.62
Output
5.410
Input
5
2.26 1.44
2.28 0.64
2.30 -0.30
1.58 0.66
3.24 0.66
Output
5.620
Input
8
6.98 2.06
6.40 1.12
5.98 0.24
5.54 -0.60
7.16 0.30
7.82 1.24
8.34 0.24
8.74 -0.76
Output
5.480
Input
5
10.44 2.06
10.90 0.80
11.48 -0.48
12.06 0.76
12.54 2.06
Output
6.040
Input
8
16.94 2.42
15.72 2.38
14.82 1.58
14.88 0.50
15.76 -0.16
16.86 -0.20
17.00 0.88
16.40 0.92
Output
6.040
Input
7
20.62 3.00
21.06 2.28
21.56 1.36
21.66 0.56
21.64 -0.52
22.14 2.32
22.62 3.04
Output
6.720
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
double sum = 0;
for (int i = 1; i <= n; i++) {
double x, y;
cin >> x >> y;
sum += y;
}
sum = sum / (double)n;
sum += 5;
printf("%.3lf\n", sum);
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
There are n employees working in company "X" (let's number them from 1 to n for convenience). Initially the employees didn't have any relationships among each other. On each of m next days one of the following events took place:
* either employee y became the boss of employee x (at that, employee x didn't have a boss before);
* or employee x gets a packet of documents and signs them; then he gives the packet to his boss. The boss signs the documents and gives them to his boss and so on (the last person to sign the documents sends them to the archive);
* or comes a request of type "determine whether employee x signs certain documents".
Your task is to write a program that will, given the events, answer the queries of the described type. At that, it is guaranteed that throughout the whole working time the company didn't have cyclic dependencies.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 105) — the number of employees and the number of events.
Each of the next m lines contains the description of one event (the events are given in the chronological order). The first number of the line determines the type of event t (1 ≤ t ≤ 3).
* If t = 1, then next follow two integers x and y (1 ≤ x, y ≤ n) — numbers of the company employees. It is guaranteed that employee x doesn't have the boss currently.
* If t = 2, then next follow integer x (1 ≤ x ≤ n) — the number of the employee who got a document packet.
* If t = 3, then next follow two integers x and i (1 ≤ x ≤ n; 1 ≤ i ≤ [number of packets that have already been given]) — the employee and the number of the document packet for which you need to find out information. The document packets are numbered started from 1 in the chronological order.
It is guaranteed that the input has at least one query of the third type.
Output
For each query of the third type print "YES" if the employee signed the document package and "NO" otherwise. Print all the words without the quotes.
Examples
Input
4 9
1 4 3
2 4
3 3 1
1 2 3
2 2
3 1 2
1 3 1
2 2
3 1 3
Output
YES
NO
YES
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void read_file(bool outToFile = true) {}
const int MAXN = 100000 + 9;
int n, nq;
vector<vector<int> > G;
int P[MAXN][(17 + 9)];
int L[MAXN];
void init() { memset(P, -1, sizeof P); }
void DFS(int u = 0, int p = -1) {
P[u][0] = p;
L[u] = p == -1 ? 0 : L[p] + 1;
for (int i = 0, sz = G[u].size(); i < sz; i++) {
int v = G[u][i];
DFS(v, u);
}
}
void build_P() {
for (int j = 1; (1 << j) < n; j++) {
for (int i = 0; i < n; i++) {
if (P[i][j - 1] != -1) {
P[i][j] = P[P[i][j - 1]][j - 1];
}
}
}
}
int LCA(int u, int v) {
if (L[u] < L[v]) swap(u, v);
int lg = 0;
while ((1 << lg) <= L[u]) lg++;
lg--;
for (int j = lg; j >= 0; j--)
if (P[u][j] != -1 && L[P[u][j]] >= L[v]) u = P[u][j];
if (u == v) return u;
for (int j = lg; j >= 0; j--)
if (P[u][j] != -1 && P[u][j] != P[v][j]) u = P[u][j], v = P[v][j];
return P[u][0];
}
struct Query {
int node, file;
Query() {}
Query(int nnode, int nfile) { node = nnode, file = nfile; }
};
Query qu[MAXN];
int rep[MAXN];
int lower[MAXN], upper[MAXN];
void join(int x, int y) {
assert(rep[x] == x);
rep[x] = y;
}
int find_rep(int x) {
if (x == rep[x]) return x;
return rep[x] = find_rep(rep[x]);
}
void sign(int x, int f) {
lower[f] = x;
x = find_rep(x);
upper[f] = x;
}
bool areTogether(int x, int y) { return find_rep(x) == find_rep(y); }
int main() {
read_file();
while (scanf("%d%d", &n, &nq) != -1) {
for (int i = 0; i < n; i++) rep[i] = i;
G.assign(n, vector<int>());
int curFile = 0;
int m = 0;
while (nq--) {
int type;
scanf("%d", &type);
if (type == 1) {
int x, y;
scanf("%d%d", &x, &y);
x--, y--;
join(x, y);
G[y].push_back(x);
} else if (type == 2) {
int x;
scanf("%d", &x);
x--;
sign(x, curFile);
curFile++;
} else {
int x, file;
scanf("%d%d", &x, &file);
x--, file--;
qu[m] = Query(x, file);
m++;
}
}
init();
for (int i = 0; i < n; i++) {
if (rep[i] == i) DFS(i, -1);
}
build_P();
for (int i = 0; i < m; i++) {
int node = qu[i].node;
int file = qu[i].file;
string ans = "NO";
int lo = lower[file];
int hi = upper[file];
if (areTogether(node, lo) && LCA(lo, node) == node) {
if (L[node] <= L[lo] && L[node] >= L[hi]) ans = "YES";
}
printf("%s\n", ans.c_str());
}
}
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
There are many interesting tasks on domino tilings. For example, an interesting fact is known. Let us take a standard chessboard (8 × 8) and cut exactly two squares out of it. It turns out that the resulting board can always be tiled using dominoes 1 × 2, if the two cut out squares are of the same color, otherwise it is impossible.
Petya grew bored with dominoes, that's why he took a chessboard (not necessarily 8 × 8), cut some squares out of it and tries to tile it using triminoes. Triminoes are reactangles 1 × 3 (or 3 × 1, because triminoes can be rotated freely), also the two extreme squares of a trimino are necessarily white and the square in the middle is black. The triminoes are allowed to put on the chessboard so that their squares matched the colors of the uncut squares of the chessboard, and also the colors must match: the black squares must be matched with the black ones only and the white ones — with the white squares. The triminoes must not protrude above the chessboard or overlap each other. All the uncut squares of the board must be covered with triminoes.
Help Petya find out if it is possible to tile his board using triminos in the described way and print one of the variants of tiling.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 1000) — the board size. Next n lines contain m symbols each and represent the board description. If some position contains ".", then the square in this position has been cut out. Symbol "w" stands for a white square, "b" stands for a black square. It is guaranteed that through adding the cut squares can result in a correct chessboard (i.e. with alternating black and white squares), thought, perhaps, of a non-standard size.
Output
If at least one correct tiling exists, in the first line print "YES" (without quotes), and then — the tiling description. The description must contain n lines, m symbols in each. The cut out squares, as well as in the input data, are marked by ".". To denote triminoes symbols "a", "b", "c", "d" can be used, and all the three squares of each trimino must be denoted by the same symbol. If two triminoes share a side, than they must be denoted by different symbols. Two triminoes not sharing a common side can be denoted by one and the same symbol (c.f. sample).
If there are multiple correct ways of tiling, it is allowed to print any. If it is impossible to tile the board using triminoes or the correct tiling, for which four symbols "a", "b", "c", "d" would be enough, doesn't exist, print "NO" (without quotes) in the first line.
Examples
Input
6 10
.w.wbw.wbw
wbwbw.w.w.
bw.wbwbwbw
w.wbw.wbwb
...wbw.w.w
..wbw.wbw.
Output
YES
.a.aaa.ccc
baccc.c.a.
ba.dddcbab
b.aaa.cbab
...bbb.b.b
..ccc.ddd.
Input
2 2
wb
bw
Output
NO
Input
1 3
wbw
Output
YES
bbb
Input
1 3
...
Output
YES
...
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
char E[1005][1005];
char D[1005][1005];
char getc1() {
char c = getchar();
while (c != '.' && c != 'w' && c != 'b') c = getchar();
return c;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
E[i][0] = '.';
for (int j = 1; j <= m; j++) {
E[i][j] = getc1();
if (D[i][j] && E[i][j] == '.') {
puts("NO");
return 0;
}
if (D[i][j]) E[i][j] = '.';
}
for (int j = 1; j <= m; j++) {
if (E[i][j] == 'b' && E[i][j - 1] == '.') {
puts("NO");
return 0;
}
if (E[i][j] == 'w' && E[i][j - 1] == '.') {
if (E[i][j + 1] == 'b') {
if (E[i][j + 2] == 'w') {
E[i][j] = E[i][j + 1] = E[i][j + 2] = '.';
D[i][j] = D[i][j + 1] = D[i][j + 2] = (i % 2 ? 'a' : 'b') - '.';
} else {
puts("NO");
return 0;
}
} else {
E[i][j] = '.';
D[i][j] = D[i + 1][j] = D[i + 2][j] = (j % 2 ? 'c' : 'd') - '.';
if (i + 2 > n) {
puts("NO");
return 0;
}
}
}
}
}
puts("YES");
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) putchar(D[i][j] + '.');
putchar(10);
}
return 0;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
Anton goes to school, his favorite lessons are arraystudying. He usually solves all the tasks pretty fast, but this time the teacher gave him a complicated one: given two arrays b and c of length n, find array a, such that:
<image>
where a and b means bitwise AND, while a or b means bitwise OR.
Usually Anton is good in arraystudying, but this problem is too hard, so Anton asks you to help.
Input
The first line of the input contains a single integers n (1 ≤ n ≤ 200 000) — the size of arrays b and c.
The second line contains n integers bi (0 ≤ bi ≤ 109) — elements of the array b.
Third line contains n integers ci (0 ≤ ci ≤ 109) — elements of the array c.
Output
If there is no solution, print - 1.
Otherwise, the only line of the output should contain n non-negative integers ai — elements of the array a. If there are multiple possible solutions, you may print any of them.
Examples
Input
4
6 8 4 4
16 22 10 10
Output
3 5 1 1
Input
5
8 25 14 7 16
19 6 9 4 25
Output
-1
### Response
```cpp
#include <bits/stdc++.h>
const double pi = acos(-1.0);
const double eps = 1e-9;
const int inf = 2 * 1e9;
const int base = 2011;
const int raz = (int)2e5 + 5;
const double deg = pi / 180;
using namespace std;
int main() {
int n;
scanf("%d", &n);
long long b[n], c[n], sb, sc;
sb = sc = 0;
for (int i = 0; i < n; i++) {
scanf("%lld", &b[i]);
sb += b[i];
}
for (int i = 0; i < n; i++) {
scanf("%lld", &c[i]);
sc += c[i];
}
long long sm = (sb + sc) / (2 * n);
long long a[n];
for (int i = 0; i < n; i++) {
a[i] = (b[i] + c[i] - sm) / n;
if (a[i] < 0) {
printf("-1");
return 0;
}
}
bool bt[31][n];
long long sbt[31];
memset(bt, 0, sizeof(bt));
memset(sbt, 0, sizeof(sbt));
for (int i = 0; i < 31; i++)
for (int j = 0; j < n; j++)
if ((a[j] & (1LL << i))) bt[i][j] = 1;
for (int i = 0; i < 31; i++) {
sbt[i] = 0;
for (int j = 0; j < n; j++) sbt[i] += bt[i][j];
}
long long cb, cc;
for (int i = 0; i < n; i++) {
cb = cc = 0;
for (int bit = 0; bit < 31; bit++) {
if (bt[bit][i]) {
cb += sbt[bit] << bit;
cc += n << bit;
} else
cc += sbt[bit] << bit;
}
if (cb != b[i] or cc != c[i]) {
printf("-1");
return 0;
}
}
for (int i = 0; i < n; i++) printf("%lld ", a[i]);
return 0;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
N players will participate in a tennis tournament. We will call them Player 1, Player 2, \ldots, Player N.
The tournament is round-robin format, and there will be N(N-1)/2 matches in total. Is it possible to schedule these matches so that all of the following conditions are satisfied? If the answer is yes, also find the minimum number of days required.
* Each player plays at most one matches in a day.
* Each player i (1 \leq i \leq N) plays one match against Player A_{i, 1}, A_{i, 2}, \ldots, A_{i, N-1} in this order.
Constraints
* 3 \leq N \leq 1000
* 1 \leq A_{i, j} \leq N
* A_{i, j} \neq i
* A_{i, 1}, A_{i, 2}, \ldots, A_{i, N-1} are all different.
Input
Input is given from Standard Input in the following format:
N
A_{1, 1} A_{1, 2} \ldots A_{1, N-1}
A_{2, 1} A_{2, 2} \ldots A_{2, N-1}
:
A_{N, 1} A_{N, 2} \ldots A_{N, N-1}
Output
If it is possible to schedule all the matches so that all of the conditions are satisfied, print the minimum number of days required; if it is impossible, print `-1`.
Examples
Input
3
2 3
1 3
1 2
Output
3
Input
4
2 3 4
1 3 4
4 1 2
3 1 2
Output
4
Input
3
2 3
3 1
1 2
Output
-1
### Response
```cpp
//besmellah
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
vector <int> adj[maxn];
int v[1010];
int indeg[maxn];
int dp[maxn];
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++){
fill(v, v + n, 0);
for (int j = 0; j < n - 1; j++){
cin >> v[j];
v[j] --;
}
for (int j = 0; j < n - 2; j++){
adj[min(i, v[j]) * n + max(i, v[j])].push_back(min(i, v[j + 1]) * n + max(i, v[j + 1]));
indeg[min(i, v[j + 1]) * n + max(i, v[j + 1])] ++;
}
}
queue <int> Q;
for (int i = 0; i < n * n; i++){
if (!indeg[i])
Q.push(i);
}
vector <int> TS;
while (Q.size()){
int v = Q.front();
Q.pop();
TS.push_back(v);
for (auto u: adj[v]){
indeg[u] --;
if (!indeg[u])
Q.push(u);
dp[u] = max(dp[u], dp[v] + 1);
}
}
if (TS.size() != n * n){
cout << -1;
return 0;
}
cout << *(max_element(dp, dp + n * n)) + 1;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
The heat during the last few days has been really intense. Scientists from all over the Berland study how the temperatures and weather change, and they claim that this summer is abnormally hot. But any scientific claim sounds a lot more reasonable if there are some numbers involved, so they have decided to actually calculate some value which would represent how high the temperatures are.
Mathematicians of Berland State University came up with a special heat intensity value. This value is calculated as follows:
Suppose we want to analyze the segment of n consecutive days. We have measured the temperatures during these n days; the temperature during i-th day equals a_i.
We denote the average temperature of a segment of some consecutive days as the arithmetic mean of the temperature measures during this segment of days. So, if we want to analyze the average temperature from day x to day y, we calculate it as \frac{∑ _{i = x}^{y} a_i}{y - x + 1} (note that division is performed without any rounding). The heat intensity value is the maximum of average temperatures over all segments of not less than k consecutive days. For example, if analyzing the measures [3, 4, 1, 2] and k = 3, we are interested in segments [3, 4, 1], [4, 1, 2] and [3, 4, 1, 2] (we want to find the maximum value of average temperature over these segments).
You have been hired by Berland State University to write a program that would compute the heat intensity value of a given period of days. Are you up to this task?
Input
The first line contains two integers n and k (1 ≤ k ≤ n ≤ 5000) — the number of days in the given period, and the minimum number of days in a segment we consider when calculating heat intensity value, respectively.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 5000) — the temperature measures during given n days.
Output
Print one real number — the heat intensity value, i. e., the maximum of average temperatures over all segments of not less than k consecutive days.
Your answer will be considered correct if the following condition holds: |res - res_0| < 10^{-6}, where res is your answer, and res_0 is the answer given by the jury's solution.
Example
Input
4 3
3 4 1 2
Output
2.666666666666667
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, k;
double maxx = 0;
int a[10005], s[10005];
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
s[i] = s[i - 1] + a[i];
if (i >= k) maxx = max(double(s[i] * 1.0 / i), maxx);
}
for (int i = k + 1; i <= n; i++) {
int j = 1;
while (i - j >= k) {
maxx = max(double((s[i] - s[j]) * 1.0 / (i - j)), maxx);
j++;
}
}
printf("%.15lf", maxx);
return 0;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
On a chessboard with a width of n and a height of n, rows are numbered from bottom to top from 1 to n, columns are numbered from left to right from 1 to n. Therefore, for each cell of the chessboard, you can assign the coordinates (r,c), where r is the number of the row, and c is the number of the column.
The white king has been sitting in a cell with (1,1) coordinates for a thousand years, while the black king has been sitting in a cell with (n,n) coordinates. They would have sat like that further, but suddenly a beautiful coin fell on the cell with coordinates (x,y)...
Each of the monarchs wanted to get it, so they decided to arrange a race according to slightly changed chess rules:
As in chess, the white king makes the first move, the black king makes the second one, the white king makes the third one, and so on. However, in this problem, kings can stand in adjacent cells or even in the same cell at the same time.
The player who reaches the coin first will win, that is to say, the player who reaches the cell with the coordinates (x,y) first will win.
Let's recall that the king is such a chess piece that can move one cell in all directions, that is, if the king is in the (a,b) cell, then in one move he can move from (a,b) to the cells (a + 1,b), (a - 1,b), (a,b + 1), (a,b - 1), (a + 1,b - 1), (a + 1,b + 1), (a - 1,b - 1), or (a - 1,b + 1). Going outside of the field is prohibited.
Determine the color of the king, who will reach the cell with the coordinates (x,y) first, if the white king moves first.
Input
The first line contains a single integer n (2 ≤ n ≤ 10^{18}) — the length of the side of the chess field.
The second line contains two integers x and y (1 ≤ x,y ≤ n) — coordinates of the cell, where the coin fell.
Output
In a single line print the answer "White" (without quotes), if the white king will win, or "Black" (without quotes), if the black king will win.
You can print each letter in any case (upper or lower).
Examples
Input
4
2 3
Output
White
Input
5
3 5
Output
Black
Input
2
2 2
Output
Black
Note
An example of the race from the first sample where both the white king and the black king move optimally:
1. The white king moves from the cell (1,1) into the cell (2,2).
2. The black king moves form the cell (4,4) into the cell (3,3).
3. The white king moves from the cell (2,2) into the cell (2,3). This is cell containing the coin, so the white king wins.
<image>
An example of the race from the second sample where both the white king and the black king move optimally:
1. The white king moves from the cell (1,1) into the cell (2,2).
2. The black king moves form the cell (5,5) into the cell (4,4).
3. The white king moves from the cell (2,2) into the cell (3,3).
4. The black king moves from the cell (4,4) into the cell (3,5). This is the cell, where the coin fell, so the black king wins.
<image>
In the third example, the coin fell in the starting cell of the black king, so the black king immediately wins.
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long n, x, y;
int main() {
cin >> n;
cin >> x >> y;
if (x + y <= n + 1)
cout << "White";
else
cout << "Black";
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
Breaking Good is a new video game which a lot of gamers want to have. There is a certain level in the game that is really difficult even for experienced gamers.
Walter William, the main character of the game, wants to join a gang called Los Hermanos (The Brothers). The gang controls the whole country which consists of n cities with m bidirectional roads connecting them. There is no road is connecting a city to itself and for any two cities there is at most one road between them. The country is connected, in the other words, it is possible to reach any city from any other city using the given roads.
The roads aren't all working. There are some roads which need some more work to be performed to be completely functioning.
The gang is going to rob a bank! The bank is located in city 1. As usual, the hardest part is to escape to their headquarters where the police can't get them. The gang's headquarters is in city n. To gain the gang's trust, Walter is in charge of this operation, so he came up with a smart plan.
First of all the path which they are going to use on their way back from city 1 to their headquarters n must be as short as possible, since it is important to finish operation as fast as possible.
Then, gang has to blow up all other roads in country that don't lay on this path, in order to prevent any police reinforcements. In case of non-working road, they don't have to blow up it as it is already malfunctional.
If the chosen path has some roads that doesn't work they'll have to repair those roads before the operation.
Walter discovered that there was a lot of paths that satisfied the condition of being shortest possible so he decided to choose among them a path that minimizes the total number of affected roads (both roads that have to be blown up and roads to be repaired).
Can you help Walter complete his task and gain the gang's trust?
Input
The first line of input contains two integers n, m (2 ≤ n ≤ 105, <image>), the number of cities and number of roads respectively.
In following m lines there are descriptions of roads. Each description consists of three integers x, y, z (1 ≤ x, y ≤ n, <image>) meaning that there is a road connecting cities number x and y. If z = 1, this road is working, otherwise it is not.
Output
In the first line output one integer k, the minimum possible number of roads affected by gang.
In the following k lines output three integers describing roads that should be affected. Each line should contain three integers x, y, z (1 ≤ x, y ≤ n, <image>), cities connected by a road and the new state of a road. z = 1 indicates that the road between cities x and y should be repaired and z = 0 means that road should be blown up.
You may output roads in any order. Each affected road should appear exactly once. You may output cities connected by a single road in any order. If you output a road, it's original state should be different from z.
After performing all operations accroding to your plan, there should remain working only roads lying on some certain shortest past between city 1 and n.
If there are multiple optimal answers output any.
Examples
Input
2 1
1 2 0
Output
1
1 2 1
Input
4 4
1 2 1
1 3 0
2 3 1
3 4 1
Output
3
1 2 0
1 3 1
2 3 0
Input
8 9
1 2 0
8 3 0
2 3 1
1 4 1
8 7 0
1 5 1
4 6 1
5 7 0
6 8 0
Output
3
2 3 0
1 5 0
6 8 1
Note
In the first test the only path is 1 - 2
In the second test the only shortest path is 1 - 3 - 4
In the third test there are multiple shortest paths but the optimal is 1 - 4 - 6 - 8
### Response
```cpp
#include <bits/stdc++.h>
using std::multiset;
const int N = 100010, M = N << 1;
int tot = 1, head[N], next[M], to[M], c[M], f1[N], f2[N];
int n, m, fa[N], fe[N];
void add(int x, int y, int z) {
to[++tot] = y;
next[tot] = head[x];
head[x] = tot;
c[tot] = z;
}
struct lr {
int x, f1, f2;
bool operator<(const lr &a) const {
return f1 != a.f1 ? f1 < a.f1 : f2 < a.f2;
}
} t;
struct E {
int x, y, ty;
void print() { printf("%d %d %d\n", x, y, ty); }
} e[N];
multiset<lr> info;
bool vis[N];
int main() {
int ans = 0;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; ++i) {
int x, y, ty;
scanf("%d%d%d", &x, &y, &ty);
add(x, y, !ty);
add(y, x, !ty);
ans += ty;
e[i] = (E){x, y, !ty};
}
memset(f1, 63, sizeof f1);
memset(f2, 63, sizeof f2);
int S = 1;
info.insert((lr){S, f1[S] = 0, f2[S] = 0});
while (!info.empty()) {
auto it = info.begin();
t = *it;
info.erase(it);
if (vis[t.x]) continue;
vis[t.x] = 1;
for (int i = head[t.x]; i; i = next[i]) {
if (f1[to[i]] > f1[t.x] + 1) {
info.insert(
(lr){to[i], f1[to[i]] = f1[t.x] + 1, f2[to[i]] = f2[t.x] + c[i]});
fa[to[i]] = t.x;
fe[to[i]] = i >> 1;
} else if (f1[to[i]] == f1[t.x] + 1 && f2[to[i]] > f2[t.x] + c[i]) {
info.insert((lr){to[i], f1[to[i]], f2[to[i]] = f2[t.x] + c[i]});
fa[to[i]] = t.x;
fe[to[i]] = i >> 1;
}
}
}
memset(vis, 0, sizeof vis);
for (int i = n; i != 1; i = fa[i]) vis[fe[i]] = 1;
printf("%d\n", ans - f1[n] + 2 * f2[n]);
for (int i = 1; i <= m; ++i) {
if (!vis[i] && !e[i].ty)
e[i].print();
else if (vis[i] && e[i].ty)
e[i].print();
}
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
There is little time left before the release of the first national operating system BerlOS. Some of its components are not finished yet — the memory manager is among them. According to the developers' plan, in the first release the memory manager will be very simple and rectilinear. It will support three operations:
* alloc n — to allocate n bytes of the memory and return the allocated block's identifier x;
* erase x — to erase the block with the identifier x;
* defragment — to defragment the free memory, bringing all the blocks as close to the beginning of the memory as possible and preserving their respective order;
The memory model in this case is very simple. It is a sequence of m bytes, numbered for convenience from the first to the m-th.
The first operation alloc n takes as the only parameter the size of the memory block that is to be allocated. While processing this operation, a free block of n successive bytes is being allocated in the memory. If the amount of such blocks is more than one, the block closest to the beginning of the memory (i.e. to the first byte) is prefered. All these bytes are marked as not free, and the memory manager returns a 32-bit integer numerical token that is the identifier of this block. If it is impossible to allocate a free block of this size, the function returns NULL.
The second operation erase x takes as its parameter the identifier of some block. This operation frees the system memory, marking the bytes of this block as free for further use. In the case when this identifier does not point to the previously allocated block, which has not been erased yet, the function returns ILLEGAL_ERASE_ARGUMENT.
The last operation defragment does not have any arguments and simply brings the occupied memory sections closer to the beginning of the memory without changing their respective order.
In the current implementation you are to use successive integers, starting with 1, as identifiers. Each successful alloc operation procession should return following number. Unsuccessful alloc operations do not affect numeration.
You are to write the implementation of the memory manager. You should output the returned value for each alloc command. You should also output ILLEGAL_ERASE_ARGUMENT for all the failed erase commands.
Input
The first line of the input data contains two positive integers t and m (1 ≤ t ≤ 100;1 ≤ m ≤ 100), where t — the amount of operations given to the memory manager for processing, and m — the available memory size in bytes. Then there follow t lines where the operations themselves are given. The first operation is alloc n (1 ≤ n ≤ 100), where n is an integer. The second one is erase x, where x is an arbitrary 32-bit integer numerical token. The third operation is defragment.
Output
Output the sequence of lines. Each line should contain either the result of alloc operation procession , or ILLEGAL_ERASE_ARGUMENT as a result of failed erase operation procession. Output lines should go in the same order in which the operations are processed. Successful procession of alloc operation should return integers, starting with 1, as the identifiers of the allocated blocks.
Examples
Input
6 10
alloc 5
alloc 3
erase 1
alloc 6
defragment
alloc 6
Output
1
2
NULL
3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int l[101], r[101], n, x, t, cnt;
bool a[101], al[101];
bool canput(int l, int r) {
for (int i = l; i <= r; i++) {
if (a[i]) return 0;
}
return 1;
}
void alloc() {
cin >> x;
for (int i = 1; i <= n - x + 1; i++) {
if (canput(i, i + x - 1)) {
cout << ++cnt << endl;
l[cnt] = i, r[cnt] = i + x - 1;
for (int j = l[cnt]; j <= r[cnt]; j++) a[j] = 1;
al[cnt] = 1;
return;
}
}
printf("NULL\n");
return;
}
void erase() {
cin >> x;
if (x > cnt || x < 1 || !al[x]) {
printf("ILLEGAL_ERASE_ARGUMENT\n");
return;
}
for (int j = l[x]; j <= r[x]; j++) a[j] = 0;
l[x] = r[x] = 0;
al[x] = 0;
return;
}
void deflagment() {
for (int i = 1; i <= cnt; i++) {
if (al[i]) {
for (int j = l[i]; j <= r[i]; j++) a[j] = 0;
while (a[l[i] - 1] == 0 && l[i] > 1) {
l[i]--;
r[i]--;
}
for (int j = l[i]; j <= r[i]; j++) a[j] = 1;
}
}
return;
}
int main() {
cin >> t >> n;
for (int i = 1; i <= t; i++) {
string s;
cin >> s;
if (s[0] == 'a') alloc();
if (s[0] == 'e') erase();
if (s[0] == 'd') deflagment();
}
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
Hilbert's Hotel is a very unusual hotel since the number of rooms is infinite! In fact, there is exactly one room for every integer, including zero and negative integers. Even stranger, the hotel is currently at full capacity, meaning there is exactly one guest in every room. The hotel's manager, David Hilbert himself, decides he wants to shuffle the guests around because he thinks this will create a vacancy (a room without a guest).
For any integer k and positive integer n, let kmod n denote the remainder when k is divided by n. More formally, r=kmod n is the smallest non-negative integer such that k-r is divisible by n. It always holds that 0≤ kmod n≤ n-1. For example, 100mod 12=4 and (-1337)mod 3=1.
Then the shuffling works as follows. There is an array of n integers a_0,a_1,…,a_{n-1}. Then for each integer k, the guest in room k is moved to room number k+a_{kmod n}.
After this shuffling process, determine if there is still exactly one guest assigned to each room. That is, there are no vacancies or rooms with multiple guests.
Input
Each test consists of multiple test cases. The first line contains a single integer t (1≤ t≤ 10^4) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 2⋅ 10^5) — the length of the array.
The second line of each test case contains n integers a_0,a_1,…,a_{n-1} (-10^9≤ a_i≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 2⋅ 10^5.
Output
For each test case, output a single line containing "YES" if there is exactly one guest assigned to each room after the shuffling process, or "NO" otherwise. You can print each letter in any case (upper or lower).
Example
Input
6
1
14
2
1 -1
4
5 5 5 1
3
3 2 1
2
0 1
5
-239 -2 -100 -3 -11
Output
YES
YES
YES
NO
NO
YES
Note
In the first test case, every guest is shifted by 14 rooms, so the assignment is still unique.
In the second test case, even guests move to the right by 1 room, and odd guests move to the left by 1 room. We can show that the assignment is still unique.
In the third test case, every fourth guest moves to the right by 1 room, and the other guests move to the right by 5 rooms. We can show that the assignment is still unique.
In the fourth test case, guests 0 and 1 are both assigned to room 3.
In the fifth test case, guests 1 and 2 are both assigned to room 2.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long x = 0, f = 0, j, q = 1, i, n, m, k;
cin >> q;
while (q--) {
x = 0;
cin >> n;
vector<long long> a(n);
unordered_map<long long, long long> m;
for (i = 0; i < n; i++) cin >> a[i];
for (i = 0; i <= n - 1; i++) m[(i + (a[i] % n) + n) % n]++;
for (auto i : m)
if (i.second > 1) x = -1;
if (x == 0)
cout << "YES";
else
cout << "NO";
cout << "\n";
}
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
Emuskald is a well-known illusionist. One of his trademark tricks involves a set of magical boxes. The essence of the trick is in packing the boxes inside other boxes.
From the top view each magical box looks like a square with side length equal to 2k (k is an integer, k ≥ 0) units. A magical box v can be put inside a magical box u, if side length of v is strictly less than the side length of u. In particular, Emuskald can put 4 boxes of side length 2k - 1 into one box of side length 2k, or as in the following figure:
<image>
Emuskald is about to go on tour performing around the world, and needs to pack his magical boxes for the trip. He has decided that the best way to pack them would be inside another magical box, but magical boxes are quite expensive to make. Help him find the smallest magical box that can fit all his boxes.
Input
The first line of input contains an integer n (1 ≤ n ≤ 105), the number of different sizes of boxes Emuskald has. Each of following n lines contains two integers ki and ai (0 ≤ ki ≤ 109, 1 ≤ ai ≤ 109), which means that Emuskald has ai boxes with side length 2ki. It is guaranteed that all of ki are distinct.
Output
Output a single integer p, such that the smallest magical box that can contain all of Emuskald’s boxes has side length 2p.
Examples
Input
2
0 3
1 5
Output
3
Input
1
0 4
Output
1
Input
2
1 10
2 2
Output
3
Note
Picture explanation. If we have 3 boxes with side length 2 and 5 boxes with side length 1, then we can put all these boxes inside a box with side length 4, for example, as shown in the picture.
In the second test case, we can put all four small boxes into a box with side length 2.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void pack(int &k, int &a, int nk, int na) {
int tk = k, ta = a;
while (tk < nk && ta > 1) {
tk++;
ta = (ta + 3) / 4;
}
k = nk;
if (ta <= na) {
a = na;
} else {
a = ta;
}
}
int main(int argc, char *argv[]) {
int n;
cin >> n;
vector<pair<int, int> > v;
for (int i = 0; i < n; i++) {
int k, a;
cin >> k >> a;
v.push_back(make_pair(k, a));
}
sort(v.begin(), v.end());
int k = 0, a = 0;
for (int i = 0; i < (int)(v.size()); i++) {
pack(k, a, v[i].first, v[i].second);
}
do {
k++;
a = (a + 3) / 4;
} while (a > 1);
cout << k << endl;
return EXIT_SUCCESS;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
Programmer Vasya is studying a new programming language &K*. The &K* language resembles the languages of the C family in its syntax. However, it is more powerful, which is why the rules of the actual C-like languages are unapplicable to it. To fully understand the statement, please read the language's description below carefully and follow it and not the similar rules in real programming languages.
There is a very powerful system of pointers on &K* — you can add an asterisk to the right of the existing type X — that will result in new type X * . That is called pointer-definition operation. Also, there is the operation that does the opposite — to any type of X, which is a pointer, you can add an ampersand — that will result in a type &X, to which refers X. That is called a dereference operation.
The &K* language has only two basic data types — void and errtype. Also, the language has operators typedef and typeof.
* The operator "typedef A B" defines a new data type B, which is equivalent to A. A can have asterisks and ampersands, and B cannot have them. For example, the operator typedef void** ptptvoid will create a new type ptptvoid, that can be used as void**.
* The operator "typeof A" returns type of A, brought to void, that is, returns the type void**...*, equivalent to it with the necessary number of asterisks (the number can possibly be zero). That is, having defined the ptptvoid type, as shown above, the typeof ptptvoid operator will return void**.
An attempt of dereferencing of the void type will lead to an error: to a special data type errtype. For errtype the following equation holds true: errtype* = &errtype = errtype. An attempt to use the data type that hasn't been defined before that will also lead to the errtype.
Using typedef, we can define one type several times. Of all the definitions only the last one is valid. However, all the types that have been defined earlier using this type do not change.
Let us also note that the dereference operation has the lower priority that the pointer operation, in other words &T * is always equal to T.
Note, that the operators are executed consecutively one by one. If we have two operators "typedef &void a" and "typedef a* b", then at first a becomes errtype, and after that b becomes errtype* = errtype, but not &void* = void (see sample 2).
Vasya does not yet fully understand this powerful technology, that's why he asked you to help him. Write a program that analyzes these operators.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the number of operators. Then follow n lines with operators. Each operator is of one of two types: either "typedef A B", or "typeof A". In the first case the B type differs from void and errtype types, and besides, doesn't have any asterisks and ampersands.
All the data type names are non-empty lines of no more than 20 lowercase Latin letters. The number of asterisks and ampersands separately in one type in any operator does not exceed 10, however if we bring some types to void with several asterisks, their number may exceed 10.
Output
For every typeof operator print on the single line the answer to that operator — the type that the given operator returned.
Examples
Input
5
typedef void* ptv
typeof ptv
typedef &&ptv node
typeof node
typeof &ptv
Output
void*
errtype
void
Input
17
typedef void* b
typedef b* c
typeof b
typeof c
typedef &b b
typeof b
typeof c
typedef &&b* c
typeof c
typedef &b* c
typeof c
typedef &void b
typeof b
typedef b******* c
typeof c
typedef &&b* c
typeof c
Output
void*
void**
void
void**
errtype
void
errtype
errtype
errtype
Note
Let's look at the second sample.
After the first two queries typedef the b type is equivalent to void*, and с — to void**.
The next query typedef redefines b — it is now equal to &b = &void* = void. At that, the с type doesn't change.
After that the с type is defined as &&b* = &&void* = &void = errtype. It doesn't influence the b type, that's why the next typedef defines c as &void* = void.
Then the b type is again redefined as &void = errtype.
Please note that the c type in the next query is defined exactly as errtype******* = errtype, and not &void******* = void******. The same happens in the last typedef.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int INF32 = 1E9;
const long long INF64 = 4E18;
const long long M = 1E9 + 7;
const double EPS = 1E-9;
const double PI = 2 * acos(0);
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& p) {
os << "[ ";
for (T x : p) os << x << " ";
os << "]" << '\n';
return os;
}
template <typename T>
ostream& operator<<(ostream& os, const set<T>& p) {
os << "{ ";
for (T x : p) os << x << " ";
os << "}" << '\n';
return os;
}
template <typename Tk, typename Tv>
ostream& operator<<(ostream& os, const map<Tk, Tv>& p) {
os << "{ ";
for (pair<Tk, Tv> x : p) os << x << " ";
os << "}" << '\n';
return os;
}
template <typename Tk, typename Tv>
ostream& operator<<(ostream& os, const pair<Tk, Tv>& p) {
os << "{" << p.first << ',' << p.second << "}";
return os;
}
void strip(string& old_type, int& star, int& amper) {
int start = -1, length = 0;
for (int i = 0; i < (int)old_type.size(); ++i) {
if (old_type[i] == '*') {
star++;
} else if (old_type[i] == '&') {
amper++;
} else {
if (start == -1) start = i;
length++;
}
}
old_type = old_type.substr(start, length);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
if (fopen("tupni.txt", "r")) {
freopen("tupni.txt", "r", stdin);
freopen("tuptuo.txt", "w", stdout);
}
int n;
cin >> n;
map<string, int> cnt;
cnt["void"] = 0;
for (int t = 0; t < n; ++t) {
string query;
cin >> query;
if (query == "typeof") {
string expression;
cin >> expression;
int star = 0, amper = 0;
strip(expression, star, amper);
if ((cnt.find(expression) != cnt.end()) and cnt[expression] != -1) {
int value = cnt[expression] + star - amper;
if (value < 0) {
cout << "errtype" << '\n';
} else {
cout << "void" << string(value, '*') << '\n';
}
} else {
cout << "errtype" << '\n';
}
} else {
string old_type, new_type;
cin >> old_type >> new_type;
int star = 0, amper = 0;
strip(old_type, star, amper);
if ((cnt.find(old_type) != cnt.end()) and cnt[old_type] != -1) {
cnt[new_type] = cnt[old_type] + star - amper;
if (cnt[new_type] < 0) {
cnt[new_type] = -1;
}
} else {
cnt[new_type] = -1;
}
}
}
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Firecrackers scare Nian the monster, but they're wayyyyy too noisy! Maybe fireworks make a nice complement.
Little Tommy is watching a firework show. As circular shapes spread across the sky, a splendid view unfolds on the night of Lunar New Year's eve.
A wonder strikes Tommy. How many regions are formed by the circles on the sky? We consider the sky as a flat plane. A region is a connected part of the plane with positive area, whose bound consists of parts of bounds of the circles and is a curve or several curves without self-intersections, and that does not contain any curve other than its boundaries. Note that exactly one of the regions extends infinitely.
Input
The first line of input contains one integer n (1 ≤ n ≤ 3), denoting the number of circles.
The following n lines each contains three space-separated integers x, y and r ( - 10 ≤ x, y ≤ 10, 1 ≤ r ≤ 10), describing a circle whose center is (x, y) and the radius is r. No two circles have the same x, y and r at the same time.
Output
Print a single integer — the number of regions on the plane.
Examples
Input
3
0 0 1
2 0 1
4 0 1
Output
4
Input
3
0 0 2
3 0 2
6 0 2
Output
6
Input
3
0 0 2
2 0 2
1 1 2
Output
8
Note
For the first example,
<image>
For the second example,
<image>
For the third example,
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
double INF = 1e100;
double EPS = 1e-9;
struct PT {
double x, y;
PT() {}
PT(double x, double y) : x(x), y(y) {}
PT(const PT &p) : x(p.x), y(p.y) {}
PT operator+(const PT &p) const { return PT(x + p.x, y + p.y); }
PT operator-(const PT &p) const { return PT(x - p.x, y - p.y); }
PT operator*(double c) const { return PT(x * c, y * c); }
PT operator/(double c) const { return PT(x / c, y / c); }
};
double dot(PT p, PT q) { return p.x * q.x + p.y * q.y; }
double dist2(PT p, PT q) { return dot(p - q, p - q); }
double cross(PT p, PT q) { return p.x * q.y - p.y * q.x; }
PT RotateCCW90(PT p) { return PT(-p.y, p.x); }
PT RotateCW90(PT p) { return PT(p.y, -p.x); }
PT RotateCCW(PT p, double t) {
return PT(p.x * cos(t) - p.y * sin(t), p.x * sin(t) + p.y * cos(t));
}
vector<PT> CircleCircleIntersection(PT a, PT b, double r, double R) {
vector<PT> ret;
double d = sqrt(dist2(a, b));
if (d > r + R || d + min(r, R) < max(r, R)) return ret;
double x = (d * d - R * R + r * r) / (2 * d);
double y = sqrt(r * r - x * x);
PT v = (b - a) / d;
ret.push_back(a + v * x + RotateCCW90(v) * y);
if (y > 0) ret.push_back(a + v * x - RotateCCW90(v) * y);
return ret;
}
const int N = 505;
int vis[N];
int edge[N][N];
PT C[N];
double R[N];
int compare(PT a, PT b) {
return abs(a.x - b.x) < EPS and abs(a.y - b.y) < EPS;
}
bool cmp(PT a, PT b) {
if (a.x != b.x) return a.x < b.x;
return a.y < b.y;
}
int uniq(vector<PT> &V) {
sort(V.begin(), V.end(), cmp);
if (V.size() == 0) return 0;
int ans = 1;
for (int i = 1; i < V.size(); i++) {
if (compare(V[i], V[i - 1]) == 0) ans++;
}
return ans;
}
void dfs(int u) {
vis[u] = 1;
for (int i = 1; i <= 500; i++) {
if (edge[u][i] == 1 and vis[i] == 0) {
dfs(i);
}
}
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> C[i].x >> C[i].y >> R[i];
}
int ans = 0;
vector<PT> all;
int e = 0, v = 0, c = 0;
for (int i = 1; i <= n; i++) {
vector<PT> V;
for (int j = 1; j <= n; j++) {
if (i == j) continue;
vector<PT> inter = CircleCircleIntersection(C[i], C[j], R[i], R[j]);
if (inter.size() > 0) edge[i][j] = 1;
for (int k = 0; k < inter.size(); k++)
V.push_back(inter[k]), all.push_back(inter[k]);
}
e += uniq(V);
}
v = uniq(all);
for (int i = 1; i <= n; i++) {
if (vis[i] == 0) {
dfs(i);
c++;
}
}
printf("%d\n", e - v + c + 1);
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
<image>
Slastyona and her loyal dog Pushok are playing a meaningless game that is indeed very interesting.
The game consists of multiple rounds. Its rules are very simple: in each round, a natural number k is chosen. Then, the one who says (or barks) it faster than the other wins the round. After that, the winner's score is multiplied by k2, and the loser's score is multiplied by k. In the beginning of the game, both Slastyona and Pushok have scores equal to one.
Unfortunately, Slastyona had lost her notepad where the history of all n games was recorded. She managed to recall the final results for each games, though, but all of her memories of them are vague. Help Slastyona verify their correctness, or, to put it another way, for each given pair of scores determine whether it was possible for a game to finish with such result or not.
Input
In the first string, the number of games n (1 ≤ n ≤ 350000) is given.
Each game is represented by a pair of scores a, b (1 ≤ a, b ≤ 109) – the results of Slastyona and Pushok, correspondingly.
Output
For each pair of scores, answer "Yes" if it's possible for a game to finish with given score, and "No" otherwise.
You can output each letter in arbitrary case (upper or lower).
Example
Input
6
2 4
75 45
8 8
16 16
247 994
1000000000 1000000
Output
Yes
Yes
Yes
No
No
Yes
Note
First game might have been consisted of one round, in which the number 2 would have been chosen and Pushok would have won.
The second game needs exactly two rounds to finish with such result: in the first one, Slastyona would have said the number 5, and in the second one, Pushok would have barked the number 3.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll MOD = 1000000007;
ll INF = 1LL << 60;
ll HI = 1000005;
ll cubic_root(ll x) {
ll lo = 0, hi = HI;
while (lo < hi) {
ll m = lo + ((hi - lo + 1) / 2);
if (m * m * m > x)
hi = m - 1;
else
lo = m;
}
return lo;
}
ll a, b, ab, cuberoot;
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n;
cin >> n;
while (n--) {
cin >> a >> b;
ab = a * b;
cuberoot = cubic_root(ab);
if (cuberoot * cuberoot * cuberoot != ab) {
cout << "No\n";
continue;
}
if (a % cuberoot == 0 && b % cuberoot == 0) {
cout << "Yes\n";
continue;
}
cout << "No\n";
}
}
``` |
### Prompt
Create a solution in cpp for the following problem:
Maxim wants to buy an apartment in a new house at Line Avenue of Metropolis. The house has n apartments that are numbered from 1 to n and are arranged in a row. Two apartments are adjacent if their indices differ by 1. Some of the apartments can already be inhabited, others are available for sale.
Maxim often visits his neighbors, so apartment is good for him if it is available for sale and there is at least one already inhabited apartment adjacent to it. Maxim knows that there are exactly k already inhabited apartments, but he doesn't know their indices yet.
Find out what could be the minimum possible and the maximum possible number of apartments that are good for Maxim.
Input
The only line of the input contains two integers: n and k (1 ≤ n ≤ 109, 0 ≤ k ≤ n).
Output
Print the minimum possible and the maximum possible number of apartments good for Maxim.
Example
Input
6 3
Output
1 3
Note
In the sample test, the number of good apartments could be minimum possible if, for example, apartments with indices 1, 2 and 3 were inhabited. In this case only apartment 4 is good. The maximum possible number could be, for example, if apartments with indices 1, 3 and 5 were inhabited. In this case all other apartments: 2, 4 and 6 are good.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long n, k;
int main() {
scanf("%lld%lld", &n, &k);
if (k == 0 || k == n) {
printf("0 0\n");
return 0;
}
long long minx = 1;
long long maxx = 0;
if (3 * k < n) {
maxx = 2 * k;
} else {
long long d = n / 3;
maxx += 2 * d;
if (n % 3 == 2) maxx++;
if (n % 3 != 0) d++;
maxx -= k - d;
}
printf("%lld %lld\n", minx, maxx);
return 0;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
In some country live wizards. They love to ride trolleybuses.
A city in this country has a trolleybus depot with n trolleybuses. Every day the trolleybuses leave the depot, one by one and go to the final station. The final station is at a distance of d meters from the depot. We know for the i-th trolleybus that it leaves at the moment of time ti seconds, can go at a speed of no greater than vi meters per second, and accelerate with an acceleration no greater than a meters per second squared. A trolleybus can decelerate as quickly as you want (magic!). It can change its acceleration as fast as you want, as well. Note that the maximum acceleration is the same for all trolleys.
Despite the magic the trolleys are still powered by an electric circuit and cannot overtake each other (the wires are to blame, of course). If a trolleybus catches up with another one, they go together one right after the other until they arrive at the final station. Also, the drivers are driving so as to arrive at the final station as quickly as possible.
You, as head of the trolleybuses' fans' club, are to determine for each trolley the minimum time by which it can reach the final station. At the time of arrival at the destination station the trolleybus does not necessarily have zero speed. When a trolley is leaving the depot, its speed is considered equal to zero. From the point of view of physics, the trolleybuses can be considered as material points, and also we should ignore the impact on the speed of a trolley bus by everything, except for the acceleration and deceleration provided by the engine.
Input
The first input line contains three space-separated integers n, a, d (1 ≤ n ≤ 105, 1 ≤ a, d ≤ 106) — the number of trolleybuses, their maximum acceleration and the distance from the depot to the final station, correspondingly.
Next n lines contain pairs of integers ti vi (0 ≤ t1 < t2... < tn - 1 < tn ≤ 106, 1 ≤ vi ≤ 106) — the time when the i-th trolleybus leaves the depot and its maximum speed, correspondingly. The numbers in the lines are separated by spaces.
Output
For each trolleybus print a single line the time it arrives to the final station. Print the times for the trolleybuses in the order in which the trolleybuses are given in the input. The answer will be accepted if the absolute or relative error doesn't exceed 10 - 4.
Examples
Input
3 10 10000
0 10
5 11
1000 1
Output
1000.5000000000
1000.5000000000
11000.0500000000
Input
1 2 26
28 29
Output
33.0990195136
Note
In the first sample the second trolleybus will catch up with the first one, that will happen at distance 510.5 meters from the depot. The trolleybuses will go the remaining 9489.5 meters together at speed 10 meters per second. As a result, both trolleybuses will arrive to the final station by the moment of time 1000.5 seconds. The third trolleybus will not catch up with them. It will arrive to the final station by the moment of time 11000.05 seconds.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, a, d;
double pret = 0;
int main(void) {
int t, v;
double curt;
scanf("%d%d%d", &n, &a, &d);
while (n--) {
scanf("%d%d", &t, &v);
double dis1 = ((double)v) * v / a / 2;
if (dis1 >= d) {
curt = sqrt(((double)2 * d) / a);
} else {
curt = ((double)v) / a + (d - dis1) / v;
}
curt += t;
if (curt < pret) {
curt = pret;
}
printf("%.10lf\n", curt);
pret = curt;
}
scanf("%*d");
return 0;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
As a result of Pinky and Brain's mysterious experiments in the Large Hadron Collider some portals or black holes opened to the parallel dimension. And the World Evil has crept to the veil between their world and ours. Brain quickly evaluated the situation and he understood that the more evil tentacles creep out and become free, the higher is the possibility that Brain will rule the world.
The collider's constriction is a rectangular grid rolled into a cylinder and consisting of n rows and m columns such as is shown in the picture below:
<image>
In this example n = 4, m = 5. Dotted lines are corridores that close each column to a ring, i. e. connect the n-th and the 1-th rows of the grid.
In the leftmost column of the grid the portals are situated and the tentacles of the World Evil are ready to creep out from there. In the rightmost column the exit doors are located. The tentacles can only get out through those doors. The segments joining the nodes of the grid are corridors.
Brain would be glad to let all the tentacles out but he faces a problem: the infinite number of tentacles can creep out of the portals, every tentacle possesses infinite length and some width and the volume of the corridors are, unfortunately, quite limited. Brain could approximately evaluate the maximal number of tentacles that will be able to crawl through every corridor.
Now help the mice to determine the maximal number of tentacles of the World Evil that will crawl out of the Large Hadron Collider.
Input
The first line of the input file contains two integers n and m (2 ≤ n ≤ 5, 2 ≤ m ≤ 105). They are the sizes of the Large Hadron Collider grid. The next m - 1 lines contain n numbers each. They are the horizontal corridors' capacities. The next m lines contain n numbers each. They are the vertical corridors' capacities. Corridors are described from left to right and from top to bottom. Every n-th vertical corridor connects nodes of the n-th and 1-th rows. A corridor's capacity is a non-negative integer that does not exceed 109.
Output
Print a single number, the number of the World Evil tentacles Pinky and Brain will command.
Please, do not use %lld specificator to read or write 64-bit integers in C++. It is preffered to use cout (also you may use %I64d).
Examples
Input
3 4
4 4 4
1 1 5
5 5 3
4 1 2
1 3 1
3 5 4
1 4 3
Output
7
Input
2 2
9 2
2 3
6 1
Output
11
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N(5), M(100010);
const long long INF(1LL << 60);
int n, m;
int st[1 << N][1 << N];
long long f[2][1 << N];
int hor[M][N], ver[M][N];
int bit(int x, int y) { return (x >> y) & 1; }
int pre(int x) { return (x + n - 1) % n; }
int nxt(int x) { return (x + 1) % n; }
int main() {
scanf("%d%d", &n, &m);
for (int i = int(0); i < int(m - 1); ++i)
for (int j = int(0); j < int(n); ++j) scanf("%d", &hor[i][j]);
for (int i = int(0); i < int(m); ++i)
for (int j = int(0); j < int(n); ++j) scanf("%d", &ver[i][j]);
for (int i = int(0); i < int(1 << n); ++i) f[0][i] = INF;
f[0][(1 << n) - 1] = 0;
int c = 0;
for (int i = int(0); i < int(1 << n); ++i)
for (int j = int(0); j < int(1 << n); ++j) {
int s = i;
for (int k = int(0); k < int(n); ++k)
if (bit(s, k)) {
for (int x = k; !bit(s, nxt(x)) && bit(j, x); x = nxt(x), s |= 1 << x)
;
for (int x = k; !bit(s, pre(x)) && bit(j, pre(x));
x = pre(x), s |= 1 << x)
;
}
st[i][j] = s;
}
for (int i = int(0); i < int(m - 1); ++i) {
for (int j = int(0); j < int(1 << n); ++j) f[c ^ 1][j] = INF;
for (int j = int(0); j < int(1 << n); ++j) {
long long w = 0;
for (int k = int(0); k < int(n); ++k)
if (!bit(j, k)) w += hor[i][k];
for (int k = int(0); k < int(1 << n); ++k)
f[c ^ 1][j & k] = min(f[c ^ 1][j & k], f[c][k] + w);
}
c ^= 1;
for (int j = int(0); j < int(1 << n); ++j) f[c ^ 1][j] = INF;
for (int j = int(0); j < int(1 << n); ++j) {
long long w = 0;
for (int k = int(0); k < int(n); ++k)
if (!bit(j, k)) w += ver[i + 1][k];
for (int k = int(0); k < int(1 << n); ++k)
f[c ^ 1][st[k][j]] = min(f[c ^ 1][st[k][j]], f[c][k] + w);
}
c ^= 1;
}
cout << f[c][0] << endl;
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
PolandBall has such a convex polygon with n veritces that no three of its diagonals intersect at the same point. PolandBall decided to improve it and draw some red segments.
He chose a number k such that gcd(n, k) = 1. Vertices of the polygon are numbered from 1 to n in a clockwise way. PolandBall repeats the following process n times, starting from the vertex 1:
Assume you've ended last operation in vertex x (consider x = 1 if it is the first operation). Draw a new segment from vertex x to k-th next vertex in clockwise direction. This is a vertex x + k or x + k - n depending on which of these is a valid index of polygon's vertex.
Your task is to calculate number of polygon's sections after each drawing. A section is a clear area inside the polygon bounded with drawn diagonals or the polygon's sides.
Input
There are only two numbers in the input: n and k (5 ≤ n ≤ 106, 2 ≤ k ≤ n - 2, gcd(n, k) = 1).
Output
You should print n values separated by spaces. The i-th value should represent number of polygon's sections after drawing first i lines.
Examples
Input
5 2
Output
2 3 5 8 11
Input
10 3
Output
2 3 4 6 9 12 16 21 26 31
Note
The greatest common divisor (gcd) of two integers a and b is the largest positive integer that divides both a and b without a remainder.
For the first sample testcase, you should output "2 3 5 8 11". Pictures below correspond to situations after drawing lines.
<image> <image> <image> <image> <image> <image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:255000000")
bool firstout = 1;
vector<string> split(const string &s, char c) {
vector<string> v;
stringstream ss(s);
string x;
while (getline(ss, x, c)) v.emplace_back(x);
return move(v);
}
void err(vector<string>::iterator it) {}
template <typename T, typename... Args>
void err(vector<string>::iterator it, T a, Args... args) {
cout << it->substr((*it)[0] == ' ', it->length()) << " = " << a << '\n';
err(++it, args...);
}
template <class T>
T &minn(T &a, T b) {
if (b < a) a = b;
return a;
}
template <class T>
T &maxx(T &a, T b) {
if (a < b) a = b;
return a;
}
int &madd(int &a, int b) {
a += b;
if (a >= 1000000007) a -= 1000000007;
return a;
}
int &msub(int &a, int b) {
a -= b;
if (a < 0) a += 1000000007;
return a;
}
int &mmult(int &a, int b) { return a = (long long)a * b % 1000000007; }
int mdiv(long long a, long long b, long long m) {
a = (a % m + m) % m;
b = (b % m + m) % m;
if (a % b == 0) return a / b;
return (a + m * mdiv(-a, m, b)) / b;
}
int n, m, q;
int nt;
int L[4012345], R[4012345];
int A[4012345];
int B[4012345];
int fndt(int i, int l, int r) {
maxx(l, L[i]);
minn(r, R[i]);
if (l > r) return 0;
if (L[i] == l && R[i] == r) return A[i];
return fndt(i + i, l, r) + fndt(i + i + 1, l, r);
}
int main() {
int i, j, k;
char c;
int a, d;
int ts;
for (ts = 1; scanf("%"
"d",
&(n)) > 0;
++ts) {
scanf(
"%"
"d",
&(m));
nt = n;
if (m > n / 2) m = n - m;
for (; nt & (nt - 1); ++nt)
;
for (i = (0); i < (nt + nt); ++i) A[i] = 0;
for (i = (nt); i < (nt + nt); ++i) L[i] = R[i] = i - nt;
for (i = (nt)-1; i >= (1); --i) L[i] = L[i + i], R[i] = R[i + i + 1];
for (i = (0); i < (n); ++i) B[i] = 0;
long long res = 1;
for (i = 0; !B[i]; i = (i + m) % n) {
int l = (i + 1) % n;
j = (i + m - 1) % n;
++res;
if (l <= j)
res += fndt(1, l, j);
else
res += fndt(1, l, n) + fndt(1, 0, j);
printf((firstout) ? "%"
"I64d"
: " %"
"I64d",
(res)),
firstout = 0;
j = nt + i;
for (; j; j /= 2) ++A[j];
j = nt + (i + m) % n;
for (; j; j /= 2) ++A[j];
B[i] = 1;
}
printf("\n"), firstout = 1;
}
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
Vasiliy is fond of solving different tasks. Today he found one he wasn't able to solve himself, so he asks you to help.
Vasiliy is given n strings consisting of lowercase English letters. He wants them to be sorted in lexicographical order (as in the dictionary), but he is not allowed to swap any of them. The only operation he is allowed to do is to reverse any of them (first character becomes last, second becomes one before last and so on).
To reverse the i-th string Vasiliy has to spent ci units of energy. He is interested in the minimum amount of energy he has to spent in order to have strings sorted in lexicographical order.
String A is lexicographically smaller than string B if it is shorter than B (|A| < |B|) and is its prefix, or if none of them is a prefix of the other and at the first position where they differ character in A is smaller than the character in B.
For the purpose of this problem, two equal strings nearby do not break the condition of sequence being sorted lexicographically.
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 100 000) — the number of strings.
The second line contains n integers ci (0 ≤ ci ≤ 109), the i-th of them is equal to the amount of energy Vasiliy has to spent in order to reverse the i-th string.
Then follow n lines, each containing a string consisting of lowercase English letters. The total length of these strings doesn't exceed 100 000.
Output
If it is impossible to reverse some of the strings such that they will be located in lexicographical order, print - 1. Otherwise, print the minimum total amount of energy Vasiliy has to spent.
Examples
Input
2
1 2
ba
ac
Output
1
Input
3
1 3 1
aa
ba
ac
Output
1
Input
2
5 5
bbb
aaa
Output
-1
Input
2
3 3
aaa
aa
Output
-1
Note
In the second sample one has to reverse string 2 or string 3. To amount of energy required to reverse the string 3 is smaller.
In the third sample, both strings do not change after reverse and they go in the wrong order, so the answer is - 1.
In the fourth sample, both strings consists of characters 'a' only, but in the sorted order string "aa" should go before string "aaa", thus the answer is - 1.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 2e5 + 5;
struct ff {
long long id;
string ss;
long long flag;
bool operator<(const ff& b) const {
if (ss != b.ss)
return ss < b.ss;
else
return id < b.id;
}
};
vector<ff> tt;
string ss;
long long dp[MAXN << 1];
long long flag[MAXN << 1];
long long c[MAXN << 1];
int main() {
long long n;
cin >> n;
memset(dp, 127, sizeof(dp));
for (int i = 1; i <= n; i++) {
cin >> c[i];
}
for (int i = 1; i <= n; ++i) {
cin >> ss;
tt.push_back({i, ss, 0});
reverse(ss.begin(), ss.end());
tt.push_back({i, ss, 1});
}
sort(tt.begin(), tt.end());
dp[0] = 0;
flag[0] = 1;
for (int i = 0; i < tt.size(); i++) {
if (flag[tt[i].id - 1]) {
if (tt[i].flag == 1) {
dp[tt[i].id] = min(dp[tt[i].id], dp[tt[i].id - 1] + c[tt[i].id]);
} else {
dp[tt[i].id] = min(dp[tt[i].id], dp[tt[i].id - 1]);
}
flag[tt[i].id] = 1;
}
}
if (dp[n] != dp[(MAXN << 1) - 2])
cout << dp[n] << endl;
else
cout << -1 << endl;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
Joisino is about to compete in the final round of a certain programming competition. In this contest, there are N problems, numbered 1 through N. Joisino knows that it takes her T_i seconds to solve problem i(1≦i≦N).
Also, there are M kinds of drinks offered to the contestants, numbered 1 through M. If Joisino takes drink i(1≦i≦M), her brain will be stimulated and the time it takes for her to solve problem P_i will become X_i seconds. It does not affect the time to solve the other problems.
A contestant is allowed to take exactly one of the drinks before the start of the contest. For each drink, Joisino wants to know how many seconds it takes her to solve all the problems if she takes that drink. Here, assume that the time it takes her to solve all the problems is equal to the sum of the time it takes for her to solve individual problems. Your task is to write a program to calculate it instead of her.
Constraints
* All input values are integers.
* 1≦N≦100
* 1≦T_i≦10^5
* 1≦M≦100
* 1≦P_i≦N
* 1≦X_i≦10^5
Input
The input is given from Standard Input in the following format:
N
T_1 T_2 ... T_N
M
P_1 X_1
P_2 X_2
:
P_M X_M
Output
For each drink, calculate how many seconds it takes Joisino to solve all the problems if she takes that drink, and print the results, one per line.
Examples
Input
3
2 1 4
2
1 1
2 3
Output
6
9
Input
5
7 2 3 8 5
3
4 2
1 7
4 13
Output
19
25
30
### Response
```cpp
#include<cstdio>
int n,m,a[105],sum=0;
int main(){
scanf("%d",&n);
for(int i=1;i<=n;i++){
scanf("%d",&a[i]);
sum+=a[i];
}
scanf("%d",&m);
while(m--){
int p,x;
scanf("%d%d",&p,&x);
printf("%d\n",sum-a[p]+x);
}
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
The dragon and the princess are arguing about what to do on the New Year's Eve. The dragon suggests flying to the mountains to watch fairies dancing in the moonlight, while the princess thinks they should just go to bed early. They are desperate to come to an amicable agreement, so they decide to leave this up to chance.
They take turns drawing a mouse from a bag which initially contains w white and b black mice. The person who is the first to draw a white mouse wins. After each mouse drawn by the dragon the rest of mice in the bag panic, and one of them jumps out of the bag itself (the princess draws her mice carefully and doesn't scare other mice). Princess draws first. What is the probability of the princess winning?
If there are no more mice in the bag and nobody has drawn a white mouse, the dragon wins. Mice which jump out of the bag themselves are not considered to be drawn (do not define the winner). Once a mouse has left the bag, it never returns to it. Every mouse is drawn from the bag with the same probability as every other one, and every mouse jumps out of the bag with the same probability as every other one.
Input
The only line of input data contains two integers w and b (0 ≤ w, b ≤ 1000).
Output
Output the probability of the princess winning. The answer is considered to be correct if its absolute or relative error does not exceed 10 - 9.
Examples
Input
1 3
Output
0.500000000
Input
5 5
Output
0.658730159
Note
Let's go through the first sample. The probability of the princess drawing a white mouse on her first turn and winning right away is 1/4. The probability of the dragon drawing a black mouse and not winning on his first turn is 3/4 * 2/3 = 1/2. After this there are two mice left in the bag — one black and one white; one of them jumps out, and the other is drawn by the princess on her second turn. If the princess' mouse is white, she wins (probability is 1/2 * 1/2 = 1/4), otherwise nobody gets the white mouse, so according to the rule the dragon wins.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long double f[1005][1005], i, j;
int w, b;
int main() {
scanf("%d %d", &w, &b);
for (int ii = 1; ii <= w; ++ii) {
i = ii;
f[ii][0] = 1;
f[ii][1] = i / (i + 1);
f[ii][2] = 2 / (i + 2) / (i + 1) * i / (i + 0) * f[ii - 1][0] + i / (i + 2);
for (int jj = 3; jj <= b; jj++) {
j = jj;
f[ii][jj] = j / (i + j) * (j - 1) / (i + j - 1) * i / (i + j - 2) *
f[ii - 1][jj - 2] +
i / (i + j) +
j / (i + j) * (j - 1) / (i + j - 1) * (j - 2) / (i + j - 2) *
f[ii][jj - 3];
}
}
printf("%.9Lf\n", f[w][b]);
return 0;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
Inna and Dima bought a table of size n × m in the shop. Each cell of the table contains a single letter: "D", "I", "M", "A".
Inna loves Dima, so she wants to go through his name as many times as possible as she moves through the table. For that, Inna acts as follows:
1. initially, Inna chooses some cell of the table where letter "D" is written;
2. then Inna can move to some side-adjacent table cell that contains letter "I"; then from this cell she can go to one of the side-adjacent table cells that contains the written letter "M"; then she can go to a side-adjacent cell that contains letter "A". Then Inna assumes that she has gone through her sweetheart's name;
3. Inna's next move can be going to one of the side-adjacent table cells that contains letter "D" and then walk on through name DIMA in the similar manner. Inna never skips a letter. So, from the letter "D" she always goes to the letter "I", from the letter "I" she always goes the to letter "M", from the letter "M" she always goes to the letter "A", and from the letter "A" she always goes to the letter "D".
Depending on the choice of the initial table cell, Inna can go through name DIMA either an infinite number of times or some positive finite number of times or she can't go through his name once. Help Inna find out what maximum number of times she can go through name DIMA.
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 103).
Then follow n lines that describe Inna and Dima's table. Each line contains m characters. Each character is one of the following four characters: "D", "I", "M", "A".
Note that it is not guaranteed that the table contains at least one letter "D".
Output
If Inna cannot go through name DIMA once, print on a single line "Poor Dima!" without the quotes. If there is the infinite number of names DIMA Inna can go through, print "Poor Inna!" without the quotes. Otherwise print a single integer — the maximum number of times Inna can go through name DIMA.
Examples
Input
1 2
DI
Output
Poor Dima!
Input
2 2
MA
ID
Output
Poor Inna!
Input
5 5
DIMAD
DIMAI
DIMAM
DDMAA
AAMID
Output
4
Note
Notes to the samples:
In the first test sample, Inna cannot go through name DIMA a single time.
In the second test sample, Inna can go through the infinite number of words DIMA. For that, she should move in the clockwise direction starting from the lower right corner.
In the third test sample the best strategy is to start from the cell in the upper left corner of the table. Starting from this cell, Inna can go through name DIMA four times.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m, Si;
const int M = 1010;
char table[M][M];
char c[4] = {'D', 'I', 'M', 'A'};
int d[5] = {0, 1, 0, -1, 0};
int V[M][M];
struct point {
int x, y;
} p;
queue<point> q;
int len = -1;
int GT(int s, int t, int l) {
if (l > Si) {
return -1;
}
for (int i = 0; i < 4; i++) {
int x = s + d[i], y = t + d[i + 1];
if (x >= 1 && x <= n && y >= 1 && y <= m && table[x][y] == c[l % 4]) {
if (V[x][y] > 0)
len = max(len, l + V[x][y]);
else if (GT(x, y, l + 1) == -1)
return -1;
}
}
len = max(len, l);
V[s][t] = len - l + 1;
if (l == 1) {
return len;
}
}
int main() {
while (scanf("%d%d", &n, &m) != EOF) {
Si = m * n;
getchar();
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
scanf("%c", &table[i][j]);
if (table[i][j] == 'D') {
p.x = i;
p.y = j;
q.push(p);
}
}
getchar();
}
memset(V, 0, sizeof(V));
if (n * m < 4 || q.empty()) {
cout << "Poor Dima!\n";
return 0;
}
int re = 0;
while (!q.empty()) {
len = -1;
p = q.front();
q.pop();
if (V[p.x][p.y] > 0) {
continue;
}
int ll = GT(p.x, p.y, 1);
if (ll == -1) {
cout << "Poor Inna!\n";
return 0;
} else
re = max(re, ll);
}
if (re >= 4)
cout << re / 4 << endl;
else
cout << "Poor Dima!\n";
}
return 0;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
Flatland has recently introduced a new type of an eye check for the driver's licence. The check goes like that: there is a plane with mannequins standing on it. You should tell the value of the minimum angle with the vertex at the origin of coordinates and with all mannequins standing inside or on the boarder of this angle.
As you spend lots of time "glued to the screen", your vision is impaired. So you have to write a program that will pass the check for you.
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of mannequins.
Next n lines contain two space-separated integers each: xi, yi (|xi|, |yi| ≤ 1000) — the coordinates of the i-th mannequin. It is guaranteed that the origin of the coordinates has no mannequin. It is guaranteed that no two mannequins are located in the same point on the plane.
Output
Print a single real number — the value of the sought angle in degrees. The answer will be considered valid if the relative or absolute error doesn't exceed 10 - 6.
Examples
Input
2
2 0
0 2
Output
90.0000000000
Input
3
2 0
0 2
-2 2
Output
135.0000000000
Input
4
2 0
0 2
-2 0
0 -2
Output
270.0000000000
Input
2
2 1
1 2
Output
36.8698976458
Note
Solution for the first sample test is shown below:
<image>
Solution for the second sample test is shown below:
<image>
Solution for the third sample test is shown below:
<image>
Solution for the fourth sample test is shown below:
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long MAX = 2500000000;
const int inf = 0x3f3f3f3f;
const double EPS = 1e-11;
const double PII = 2 * asin(1.0);
const long long mod = 1e9 + 7;
const long long mod2 = 1000000016531;
const long long mod3 = 1000000014367;
int double_cmp(double x, double y = 0, double tol = EPS) {
return (x <= y + tol) ? (x + tol < y) ? -1 : 0 : 1;
}
double angle[100010];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
int a, b;
scanf("%d%d", &a, &b);
angle[i] = acos((10.0 * a) / (sqrtl(100.0) * sqrtl(a * a + b * b)));
if ((a < 0.0 && b < 0.0) || (a >= 0.0 && b < 0.0))
angle[i] = (2.0 * PII) - angle[i];
}
sort(angle, angle + n);
double menor = 400000000.0;
for (int i = 1; i < n; ++i) {
menor = min(menor,
abs((180.0 * ((2 * PII) - (angle[i] - angle[i - 1]))) / PII));
}
menor = min(menor, abs((180.0 * (angle[n - 1] - angle[0])) / PII));
printf("%.14lf\n", menor);
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
The hero of our story, Valera, and his best friend Arcady are still in school, and therefore they spend all the free time playing turn-based strategy "GAGA: Go And Go Again". The gameplay is as follows.
There are two armies on the playing field each of which consists of n men (n is always even). The current player specifies for each of her soldiers an enemy's soldier he will shoot (a target) and then all the player's soldiers shot simultaneously. This is a game world, and so each soldier shoots perfectly, that is he absolutely always hits the specified target. If an enemy soldier is hit, he will surely die. It may happen that several soldiers had been indicated the same target. Killed soldiers do not participate in the game anymore.
The game "GAGA" consists of three steps: first Valera makes a move, then Arcady, then Valera again and the game ends.
You are asked to calculate the maximum total number of soldiers that may be killed during the game.
Input
The input data consist of a single integer n (2 ≤ n ≤ 108, n is even). Please note that before the game starts there are 2n soldiers on the fields.
Output
Print a single number — a maximum total number of soldiers that could be killed in the course of the game in three turns.
Examples
Input
2
Output
3
Input
4
Output
6
Note
The first sample test:
1) Valera's soldiers 1 and 2 shoot at Arcady's soldier 1.
2) Arcady's soldier 2 shoots at Valera's soldier 1.
3) Valera's soldier 1 shoots at Arcady's soldier 2.
There are 3 soldiers killed in total: Valera's soldier 1 and Arcady's soldiers 1 and 2.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
cout << n * 2 - (n * 2) / 4;
return 0;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
RedDreamer has an array a consisting of n non-negative integers, and an unlucky integer T.
Let's denote the misfortune of array b having length m as f(b) — the number of pairs of integers (i, j) such that 1 ≤ i < j ≤ m and b_i + b_j = T. RedDreamer has to paint each element of a into one of two colors, white and black (for each element, the color is chosen independently), and then create two arrays c and d so that all white elements belong to c, and all black elements belong to d (it is possible that one of these two arrays becomes empty). RedDreamer wants to paint the elements in such a way that f(c) + f(d) is minimum possible.
For example:
* if n = 6, T = 7 and a = [1, 2, 3, 4, 5, 6], it is possible to paint the 1-st, the 4-th and the 5-th elements white, and all other elements black. So c = [1, 4, 5], d = [2, 3, 6], and f(c) + f(d) = 0 + 0 = 0;
* if n = 3, T = 6 and a = [3, 3, 3], it is possible to paint the 1-st element white, and all other elements black. So c = [3], d = [3, 3], and f(c) + f(d) = 0 + 1 = 1.
Help RedDreamer to paint the array optimally!
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases. Then t test cases follow.
The first line of each test case contains two integers n and T (1 ≤ n ≤ 10^5, 0 ≤ T ≤ 10^9) — the number of elements in the array and the unlucky integer, respectively.
The second line contains n integers a_1, a_2, ..., a_n (0 ≤ a_i ≤ 10^9) — the elements of the array.
The sum of n over all test cases does not exceed 10^5.
Output
For each test case print n integers: p_1, p_2, ..., p_n (each p_i is either 0 or 1) denoting the colors. If p_i is 0, then a_i is white and belongs to the array c, otherwise it is black and belongs to the array d.
If there are multiple answers that minimize the value of f(c) + f(d), print any of them.
Example
Input
2
6 7
1 2 3 4 5 6
3 6
3 3 3
Output
1 0 0 1 1 0
1 0 0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b);
void print(long long arr[], long long n);
void printv(vector<long long> arr);
signed main() {
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
long long k;
cin >> k;
vector<long long> arr(n);
unordered_map<long long, long long> m;
for (long long i = 0; i < n; i++) {
cin >> arr[i];
m[arr[i]]++;
}
vector<long long> tem = arr;
sort(tem.begin(), tem.end());
set<long long> a, b;
if (arr[0] * 2 != k) a.insert(arr[0]);
for (long long i = 1; i < n; i++) {
if (arr[i] * 2 == k) continue;
if (a.find(k - arr[i]) == a.end())
a.insert(arr[i]);
else
b.insert(arr[i]);
}
long long ii = 0;
for (long long i = 0; i < n; i++) {
if (a.find(arr[i]) != a.end())
cout << 1 << " ";
else if (b.find(arr[i]) != b.end())
cout << 0 << " ";
else {
cout << ii << " ";
ii = (ii + 1) % 2;
}
}
cout << "\n";
}
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
void print(long long arr[], long long n) {
for (long long i = 0; i < n; i++) cout << arr[i] << " ";
cout << "\n";
}
void printv(vector<long long> arr) {
for (long long i = 0; i < arr.size(); i++) cout << arr[i] << " ";
cout << "\n";
}
``` |
### Prompt
Generate a cpp solution to the following problem:
This is an interactive problem.
Yui is a girl who enjoys playing Mahjong.
<image>
She has a mysterious set which consists of tiles (this set can be empty). Each tile has an integer value between 1 and n, and at most n tiles in the set have the same value. So the set can contain at most n^2 tiles.
You want to figure out which values are on the tiles. But Yui is shy, she prefers to play a guessing game with you.
Let's call a set consisting of three tiles triplet if their values are the same. For example, \{2, 2, 2\} is a triplet, but \{2, 3, 3\} is not.
Let's call a set consisting of three tiles straight if their values are consecutive integers. For example, \{2, 3, 4\} is a straight, but \{1, 3, 5\} is not.
At first, Yui gives you the number of triplet subsets and straight subsets of the initial set respectively. After that, you can insert a tile with an integer value between 1 and n into the set at most n times. Every time you insert a tile, you will get the number of triplet subsets and straight subsets of the current set as well.
Note that two tiles with the same value are treated different. In other words, in the set \{1, 1, 2, 2, 3\} you can find 4 subsets \{1, 2, 3\}.
Try to guess the number of tiles in the initial set with value i for all integers i from 1 to n.
Input
The first line contains a single integer n (4 ≤ n ≤ 100).
The second line contains two integers which represent the number of triplet subsets and straight subsets of the initial set respectively.
Output
When you are ready to answer, print a single line of form "! a_1 a_2 … a_n" (0 ≤ a_i ≤ n), where a_i is equal to the number of tiles in the initial set with value i.
Interaction
To insert a tile, print a single line of form "+ x" (1 ≤ x ≤ n), where x is the value of the tile you insert. Then you should read two integers which represent the number of triplet subsets and straight subsets of the current set respectively.
After printing a line, do not forget to 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.
You will get Wrong answer if you insert more than n tiles.
Hacks
To make a hack you should provide a test in such format:
The first line contains a single integer n (4 ≤ n ≤ 100).
The second line contains n integers a_1,a_2,…,a_n (0 ≤ a_i ≤ n) — a_i is equal to the number of tiles with value i in the set.
Example
Input
5
1 6
2 9
5 12
5 24
6 24
Output
+ 1
+ 1
+ 2
+ 5
! 2 1 3 0 2
Note
In the first test, the initial set of tiles is \{1, 1, 2, 3, 3, 3, 5, 5\}. It has only one triplet subset \{3, 3, 3\} and six straight subsets, all equal to \{1, 2, 3\}. After inserting a tile with value 1 the set of tiles will be \{1, 1, 1, 2, 3, 3, 3, 5, 5\} and will have two triplet subsets \{1, 1, 1\}, \{3, 3, 3\} and nine straight subsets, all equal to \{1, 2, 3\}.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int t[105], s[105], ans[105];
void ask(int x, int i) {
cout << "+ " << x << endl;
cin >> t[i] >> s[i];
}
int calc(int x) {
int i = 1;
while (1) {
if (i * (i - 1) / 2 == x) return i;
++i;
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
int n;
cin >> n;
cin >> t[0] >> s[0];
memset(ans, -1, sizeof ans);
for (int i = 1; i <= n - 1; ++i) {
ask(i, i);
}
ask(1, n);
for (int i = n; i >= 1; --i) t[i] -= t[i - 1], s[i] -= s[i - 1];
ans[1] = t[n] - t[1];
for (int i = 2; i <= n - 1; ++i) {
if (t[i]) ans[i] = calc(t[i]);
}
if (ans[3] == -1) ans[3] = (s[2] > 0);
if (ans[2] == -1) ans[2] = s[n] / (ans[3] + 1) - 1;
for (int i = 3; i <= n - 2; ++i) {
if (ans[i + 1] == -1) {
s[i] -= (ans[i - 1] + 1) * (ans[i - 2] + 1);
ans[i + 1] = (s[i] > 0);
}
}
ans[n] = (s[n - 1] - (ans[n - 2] + 1) * (ans[n - 3] + 1)) / (ans[n - 2] + 1);
cout << "! ";
for (int i = 1; i <= n; ++i) cout << ans[i] << ' ';
cout << '\n';
return 0;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
You are given two strings a and b. You have to remove the minimum possible number of consecutive (standing one after another) characters from string b in such a way that it becomes a subsequence of string a. It can happen that you will not need to remove any characters at all, or maybe you will have to remove all of the characters from b and make it empty.
Subsequence of string s is any such string that can be obtained by erasing zero or more characters (not necessarily consecutive) from string s.
Input
The first line contains string a, and the second line — string b. Both of these strings are nonempty and consist of lowercase letters of English alphabet. The length of each string is no bigger than 105 characters.
Output
On the first line output a subsequence of string a, obtained from b by erasing the minimum number of consecutive characters.
If the answer consists of zero characters, output «-» (a minus sign).
Examples
Input
hi
bob
Output
-
Input
abca
accepted
Output
ac
Input
abacaba
abcdcba
Output
abcba
Note
In the first example strings a and b don't share any symbols, so the longest string that you can get is empty.
In the second example ac is a subsequence of a, and at the same time you can obtain it by erasing consecutive symbols cepted from string b.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char** argv) {
char a[100001] = {};
char b[100001] = {};
scanf("%s", a);
scanf("%s", b);
size_t alen = strlen(a);
size_t blen = strlen(b);
char* aend = a + alen;
char* cura = a;
char* curb = b;
std::vector<int> prefixes;
prefixes.reserve(blen);
prefixes.push_back(-1);
for (size_t i = 0; i < blen; ++i) {
while (cura != aend) {
if (*curb == *cura) {
prefixes.push_back(cura - a);
++cura;
break;
}
++cura;
}
if (cura == aend) break;
++curb;
}
cura = a + alen - 1;
curb = b + blen - 1;
std::vector<int> postfix;
postfix.reserve(blen);
postfix.push_back(alen);
for (size_t i = 0; i < blen; ++i) {
while (cura != a - 1) {
if (*curb == *cura) {
postfix.push_back(cura - a);
--cura;
break;
}
--cura;
}
if (cura == a - 1) break;
--curb;
}
int curMax = -1;
int curPostfixIdx = postfix.size() - 1;
std::pair<int, int> res;
for (int i = 0; i < prefixes.size() && curPostfixIdx >= 0; ++i) {
while (blen - curPostfixIdx <= i || prefixes[i] >= postfix[curPostfixIdx]) {
--curPostfixIdx;
if (curPostfixIdx < 0) break;
}
if (curMax <= (i + curPostfixIdx)) {
curMax = i + curPostfixIdx;
res.first = i;
res.second = curPostfixIdx;
}
}
std::string qqq(b, b + res.first);
if (res.second >= 0) qqq.insert(qqq.end(), b + blen - res.second, b + blen);
if (qqq.length())
std::cout << qqq;
else
std::cout << '-';
return 0;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
As you know, lemmings like jumping. For the next spectacular group jump n lemmings gathered near a high rock with k comfortable ledges on it. The first ledge is situated at the height of h meters, the second one is at the height of 2h meters, and so on (the i-th ledge is at the height of i·h meters). The lemmings are going to jump at sunset, and there's not much time left.
Each lemming is characterized by its climbing speed of vi meters per minute and its weight mi. This means that the i-th lemming can climb to the j-th ledge in <image> minutes.
To make the jump beautiful, heavier lemmings should jump from higher ledges: if a lemming of weight mi jumps from ledge i, and a lemming of weight mj jumps from ledge j (for i < j), then the inequation mi ≤ mj should be fulfilled.
Since there are n lemmings and only k ledges (k ≤ n), the k lemmings that will take part in the jump need to be chosen. The chosen lemmings should be distributed on the ledges from 1 to k, one lemming per ledge. The lemmings are to be arranged in the order of non-decreasing weight with the increasing height of the ledge. In addition, each lemming should have enough time to get to his ledge, that is, the time of his climb should not exceed t minutes. The lemmings climb to their ledges all at the same time and they do not interfere with each other.
Find the way to arrange the lemmings' jump so that time t is minimized.
Input
The first line contains space-separated integers n, k and h (1 ≤ k ≤ n ≤ 105, 1 ≤ h ≤ 104) — the total number of lemmings, the number of ledges and the distance between adjacent ledges.
The second line contains n space-separated integers m1, m2, ..., mn (1 ≤ mi ≤ 109), where mi is the weight of i-th lemming.
The third line contains n space-separated integers v1, v2, ..., vn (1 ≤ vi ≤ 109), where vi is the speed of i-th lemming.
Output
Print k different numbers from 1 to n — the numbers of the lemmings who go to ledges at heights h, 2h, ..., kh, correspondingly, if the jump is organized in an optimal way. If there are multiple ways to select the lemmings, pick any of them.
Examples
Input
5 3 2
1 2 3 2 1
1 2 1 2 10
Output
5 2 4
Input
5 3 10
3 4 3 2 1
5 4 3 2 1
Output
4 3 1
Note
Let's consider the first sample case. The fifth lemming (speed 10) gets to the ledge at height 2 in <image> minutes; the second lemming (speed 2) gets to the ledge at height 4 in 2 minutes; the fourth lemming (speed 2) gets to the ledge at height 6 in 3 minutes. All lemmings manage to occupy their positions in 3 minutes.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int tam = 200010;
const int MOD = 1000000007;
const int MOD1 = 998244353;
const double EPS = 1e-9;
const double PI = acos(-1);
pair<pair<int, int>, int> ar[tam];
int res[tam];
int n, k, h;
bool first(double t) {
int mul = 1;
for (int i = 0, asdz = n; i < asdz; i++) {
if (mul <= k && mul * h <= ar[i].first.second * t) {
res[mul - 1] = ar[i].second + 1;
mul++;
}
}
return mul > k;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k >> h;
for (int i = 0, asdz = n; i < asdz; i++) {
cin >> ar[i].first.first;
ar[i].second = i;
}
for (int i = 0, asdz = n; i < asdz; i++) cin >> ar[i].first.second;
sort(ar, ar + n);
double lo = 0, hi = 1000000000, mid, resp;
for (int i = 0, asdz = 100; i < asdz; i++) {
mid = (lo + hi) / 2;
if (first(mid))
resp = mid, hi = mid;
else
lo = mid;
}
assert(first(resp));
for (int i = 0, asdz = k; i < asdz; i++) {
if (i > 0) cout << ' ';
cout << res[i];
}
cout << '\n';
return 0;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
Numbers of black and white points are placed on a plane. Let's imagine that a straight line of infinite length is drawn on the plane. When the line does not meet any of the points, the line divides these points into two groups. If the division by such a line results in one group consisting only of black points and the other consisting only of white points, we say that the line "separates black and white points".
Let's see examples in Figure 3. In the leftmost example, you can easily find that the black and white points can be perfectly separated by the dashed line according to their colors. In the remaining three examples, there exists no such straight line that gives such a separation.
<image>
Figure 3: Example planes
In this problem, given a set of points with their colors and positions, you are requested to decide whether there exists a straight line that separates black and white points.
Input
The input is a sequence of datasets, each of which is formatted as follows.
n m
x1 y1
.
.
.
xn yn
xn+1 yn+1
.
.
.
xn+m yn+m
The first line contains two positive integers separated by a single space; n is the number of black points, and m is the number of white points. They are less than or equal to 100. Then n + m lines representing the coordinates of points follow. Each line contains two integers xi and yi separated by a space, where (xi , yi ) represents the x-coordinate and the y-coordinate of the i-th point. The color of the i-th point is black for 1 ≤ i ≤ n, and is white for n + 1 ≤ i ≤ n + m.
All the points have integral x- and y-coordinate values between 0 and 10000 inclusive. You can also assume that no two points have the same position.
The end of the input is indicated by a line containing two zeros separated by a space.
Output
For each dataset, output "YES" if there exists a line satisfying the condition. If not, output "NO". In either case, print it in one line for each input dataset.
Example
Input
3 3
100 700
200 200
600 600
500 100
500 300
800 500
3 3
100 300
400 600
400 100
600 400
500 900
300 300
3 4
300 300
500 300
400 600
100 100
200 900
500 900
800 100
1 2
300 300
100 100
500 500
1 1
100 100
200 100
2 2
0 0
500 700
1000 1400
1500 2100
2 2
0 0
1000 1000
1000 0
0 1000
3 3
0 100
4999 102
10000 103
5001 102
10000 102
0 101
3 3
100 100
200 100
100 200
0 0
400 0
0 400
3 3
2813 1640
2583 2892
2967 1916
541 3562
9298 3686
7443 7921
0 0
Output
YES
NO
NO
NO
YES
YES
NO
NO
NO
YES
### Response
```cpp
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <climits>
#include <cfloat>
#include <map>
#include <utility>
#include <set>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <sstream>
#include <complex>
#include <stack>
#include <queue>
#include <numeric>
#include <iomanip>
#define REP(i,n) for(i=0; i < (n); i++)
#define REPONE(i, n) for(i=1; i <= (n); i++)
#define LOOP(n) for(int loopCount=1; loopCount <= (n); loopCount++)
#define ITER(c) __typeof((c).begin())
#define EACH(c,it) for(ITER(c) it =(c).begin(); it!=(c).end(); it++)
#define SZ(c) ((int) (c).size())
#define ALL(c) c.begin(), c.end()
#define SUM(c) accumulate(ALL(c), 0)
#define EXIST(c,v) (find(ALL(c), (v)) != (c).end())
#define PB push_back
#define MP make_pair
using namespace std;
static const double EPS = 1e-8;
static const double PI = 3.141592653589793238462643383279;
/*
typedef complex<double> point;
template<typename T>
int sig2(T x){
if(abs(x)<EPS) return 0;
if(x>0) return 1;
return -1;
}
double det(point p1, point p2, point q){
return p2.real()*q.imag()+p1.real()*p2.imag()+q.real()*p1.imag()
-p2.real()*p1.imag()-q.real()*p2.imag()-q.imag()*p1.real();
}
int main(){
int i,j,k,n,m;
double x,y,bxma,byma,bxmi,bymi,wxma,wyma,wxmi,wymi;
bool yes;
while(scanf("%d%d",&n,&m)){
if(n==0 && m==0) break;
bxma=byma=wxma=wyma=-1e99;
bxmi=bymi=wxmi=wymi=1e99;
yes=false;
vector<point> bs(n), ws(m);
REP(i,n){
scanf("%lf%lf",&x,&y);
bs[i]=point(x,y);
bxma=max(bxma, x);
byma=max(byma, y);
bxmi=min(bxmi, x);
bymi=min(bymi, y);
}
REP(i,m){
scanf("%lf%lf",&x,&y);
ws[i]=point(x,y);
wxma=max(wxma, x);
wyma=max(wyma, y);
wxmi=min(wxmi, x);
wymi=min(wymi, y);
}
if(bxma<wxmi||bxmi>wxma||byma<wymi||bymi>wyma){
printf("YES\n");
continue;
}
if(n==1 && m==1){
printf("YES\n");
continue;
}
int w=0, b;
REP(i,n)for(j=i+1;j<n;j++){
w = 0;
REP(k,m) w+=sig2(det(bs[i],bs[j],ws[k]));
if(abs(w)<m)break;
REP(k,n)if(sig2(det(bs[i],bs[j],bs[k]))==sig2(w))break;
if(k==n){
yes = true;
goto end;
}
}
swap(n,m);
swap(bs,ws);
REP(i,n)for(j=i+1;j<n;j++){
w = 0;
REP(k,m) w+=sig2(det(bs[i],bs[j],ws[k]));
if(abs(w)<m)break;
REP(k,n)if(sig2(det(bs[i],bs[j],bs[k]))==sig2(w))break;
if(k==n){
yes = true;
goto end;
}
}
REP(i,n)REP(j,m){
w = b = 0;
REP(k,m) w+=sig2(det(bs[i],ws[j],ws[k]));
if(abs(w)<m-1)break;
REP(k,n) b+=sig2(det(bs[i],ws[j],bs[k]));
if(abs(b)<n-1)break;
if(w*b<0){
yes = true;
goto end;
}
}
end:;
if(yes)printf("YES\n");
else printf("NO\n");
}
return 0;
}
*/
#define N 80000
int main(){
int i,j,n,m;
double bma,bmi,wma,wmi,ang=PI/N,tmp;
static double bxs[100], wxs[100], bys[100], wys[100];
while(scanf("%d%d",&n,&m)){
if(n==0 && m==0) break;
REP(i,n)scanf("%lf%lf",bxs+i,bys+i);
REP(i,m)scanf("%lf%lf",wxs+i,wys+i);
REP(i,N){
bma=wma=-1e99;
bmi=wmi=1e99;
REP(j,n){
tmp = cos(ang*i)*bxs[j]-sin(ang*i)*bys[j];
if(tmp<bmi)bmi=tmp;
if(tmp>bma)bma=tmp;
}
REP(j,m){
tmp = cos(ang*i)*wxs[j]-sin(ang*i)*wys[j];
if(bmi<tmp && tmp<bma) goto mark;
if(tmp<wmi)wmi=tmp;
if(tmp>wma)wma=tmp;
}
if((bma < wmi - EPS) || (wma < bmi - EPS)) break;
mark:;
}
if(i==N)printf("NO\n");
else printf("YES\n");
}
return 0;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
Artsem is on vacation and wants to buy souvenirs for his two teammates. There are n souvenir shops along the street. In i-th shop Artsem can buy one souvenir for ai dollars, and he cannot buy more than one souvenir in one shop. He doesn't want to introduce envy in his team, so he wants to buy two souvenirs with least possible difference in price.
Artsem has visited the shopping street m times. For some strange reason on the i-th day only shops with numbers from li to ri were operating (weird? yes it is, but have you ever tried to come up with a reasonable legend for a range query problem?). For each visit, Artsem wants to know the minimum possible difference in prices of two different souvenirs he can buy in the opened shops.
In other words, for each Artsem's visit you should find the minimum possible value of |as - at| where li ≤ s, t ≤ ri, s ≠ t.
Input
The first line contains an integer n (2 ≤ n ≤ 105).
The second line contains n space-separated integers a1, ..., an (0 ≤ ai ≤ 109).
The third line contains the number of queries m (1 ≤ m ≤ 3·105).
Next m lines describe the queries. i-th of these lines contains two space-separated integers li and ri denoting the range of shops working on i-th day (1 ≤ li < ri ≤ n).
Output
Print the answer to each query in a separate line.
Example
Input
8
3 1 4 1 5 9 2 6
4
1 8
1 3
4 8
5 7
Output
0
1
1
3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, q;
pair<int, int> a[100001];
int pos[100001];
vector<pair<int, int> > qr[100001];
int max1[262144];
int max2[262144];
int ans[300001];
void upd1(int id, int l, int r, int x, int v) {
if (l == r) {
max1[id] = max(max1[id], v);
return;
}
int mid = (l + r) / 2;
if (x <= mid)
upd1(id * 2, l, mid, x, v);
else
upd1(id * 2 + 1, mid + 1, r, x, v);
max1[id] = max(max1[id * 2], max1[id * 2 + 1]);
}
void upd2(int id, int l, int r, int x, int v) {
if (l == r) {
max2[id] = max(max2[id], v);
return;
}
int mid = (l + r) / 2;
if (x <= mid)
upd2(id * 2, l, mid, x, v);
else
upd2(id * 2 + 1, mid + 1, r, x, v);
max2[id] = max(max2[id * 2], max2[id * 2 + 1]);
}
int qr1(int id, int l, int r, int ll, int rr) {
if (r < ll || l > rr) return -1e9;
if (ll <= l && r <= rr) return max1[id];
int mid = (l + r) / 2;
return max(qr1(id * 2, l, mid, ll, rr), qr1(id * 2 + 1, mid + 1, r, ll, rr));
}
int qr2(int id, int l, int r, int ll, int rr) {
if (r < ll || l > rr) return -1e9;
if (ll <= l && r <= rr) return max2[id];
int mid = (l + r) / 2;
return max(qr2(id * 2, l, mid, ll, rr), qr2(id * 2 + 1, mid + 1, r, ll, rr));
}
void wash(int id, int l, int r) {
max2[id] = -1e9;
if (l == r) return;
int mid = (l + r) / 2;
wash(id * 2, l, mid);
wash(id * 2 + 1, mid + 1, r);
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i].first;
a[i].second = i;
}
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) pos[a[i].second] = i;
wash(1, 1, n);
cin >> q;
for (int i = 1; i <= q; i++) {
int l, r;
cin >> l >> r;
qr[r].push_back({l, i});
}
for (int i = 1; i <= n; i++) {
int len = 1e9, lb;
while (len >= 0) {
int val = a[pos[i]].first - len;
lb = lower_bound(a + 1, a + n + 1, make_pair(val, 0)) - a;
int maxi = qr1(1, 1, n, lb, pos[i]);
if (maxi == 0) break;
upd2(1, 1, n, maxi, a[pos[maxi]].first - a[pos[i]].first);
len = (a[pos[i]].first - a[pos[maxi]].first + 1) / 2 - 1;
}
len = 1e9;
while (len >= 0) {
int val = a[pos[i]].first + len;
lb = lower_bound(a + 1, a + n + 1, make_pair(val + 1, 0)) - a - 1;
int maxi = qr1(1, 1, n, pos[i], lb);
if (maxi == 0) break;
upd2(1, 1, n, maxi, a[pos[i]].first - a[pos[maxi]].first);
len = (a[pos[maxi]].first - a[pos[i]].first + 1) / 2 - 1;
}
upd1(1, 1, n, pos[i], i);
for (auto cur : qr[i]) ans[cur.second] = -qr2(1, 1, n, cur.first, i);
}
for (int i = 1; i <= q; i++) {
cout << ans[i] << '\n';
}
}
``` |
### Prompt
Generate a CPP solution to the following problem:
Little Petya likes positive integers a lot. Recently his mom has presented him a positive integer a. There's only one thing Petya likes more than numbers: playing with little Masha. It turned out that Masha already has a positive integer b. Petya decided to turn his number a into the number b consecutively performing the operations of the following two types:
1. Subtract 1 from his number.
2. Choose any integer x from 2 to k, inclusive. Then subtract number (a mod x) from his number a. Operation a mod x means taking the remainder from division of number a by number x.
Petya performs one operation per second. Each time he chooses an operation to perform during the current move, no matter what kind of operations he has performed by that moment. In particular, this implies that he can perform the same operation any number of times in a row.
Now he wonders in what minimum number of seconds he could transform his number a into number b. Please note that numbers x in the operations of the second type are selected anew each time, independently of each other.
Input
The only line contains three integers a, b (1 ≤ b ≤ a ≤ 1018) and k (2 ≤ k ≤ 15).
Please do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
Print a single integer — the required minimum number of seconds needed to transform number a into number b.
Examples
Input
10 1 4
Output
6
Input
6 3 10
Output
2
Input
1000000000000000000 1 3
Output
666666666666666667
Note
In the first sample the sequence of numbers that Petya gets as he tries to obtain number b is as follows: 10 → 8 → 6 → 4 → 3 → 2 → 1.
In the second sample one of the possible sequences is as follows: 6 → 4 → 3.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T sqr(T x) {
return x * x;
}
const double EPS = 1e-6;
const int INF = 0x3fffffff;
const long long LINF = INF * 1ll * INF;
const double PI = acos(-1.0);
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long d[400005];
long long a, b, k, lcm;
long long bfs(long long a, long long target) {
queue<int> q;
memset(d, -1, sizeof(d));
q.push(a);
d[a] = 0;
while (!q.empty()) {
int st = q.front();
q.pop();
for (int i = 2; i <= k; i++) {
if (st % i == 0) continue;
int tmp = st - st % i;
if (tmp < 0) tmp += lcm;
if (d[tmp] <= 0) {
d[tmp] = d[st] + 1;
q.push(tmp);
}
}
int tmp = st - 1;
if (tmp < 0) tmp += lcm;
if (d[tmp] <= 0) {
d[tmp] = d[st] + 1;
q.push(tmp);
}
}
return d[target];
}
int main(void) {
cin >> a >> b >> k;
lcm = 1;
for (int i = 2; i <= k; i++) lcm = lcm / gcd(lcm, i) * i;
long long ans = 0;
if (a / lcm == b / lcm) {
if (a % lcm != b % lcm) ans = bfs(a % lcm, b % lcm);
} else {
if (a % lcm) ans += bfs(a % lcm, 0);
if (b % lcm) ans += bfs(0, b % lcm);
ans += (a / lcm - b / lcm - 1) * bfs(0, 0);
}
cout << ans << endl;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
Given are an integer N and arrays S, T, U, and V, each of length N. Construct an N×N matrix a that satisfy the following conditions:
* a_{i,j} is an integer.
* 0 \leq a_{i,j} \lt 2^{64}.
* If S_{i} = 0, the bitwise AND of the elements in the i-th row is U_{i}.
* If S_{i} = 1, the bitwise OR of the elements in the i-th row is U_{i}.
* If T_{i} = 0, the bitwise AND of the elements in the i-th column is V_{i}.
* If T_{i} = 1, the bitwise OR of the elements in the i-th column is V_{i}.
However, there may be cases where no matrix satisfies the conditions.
Constraints
* All values in input are integers.
* 1 \leq N \leq 500
* 0 \leq S_{i} \leq 1
* 0 \leq T_{i} \leq 1
* 0 \leq U_{i} \lt 2^{64}
* 0 \leq V_{i} \lt 2^{64}
Input
Input is given from Standard Input in the following format:
N
S_{1} S_{2} ... S_{N}
T_{1} T_{2} ... T_{N}
U_{1} U_{2} ... U_{N}
V_{1} V_{2} ... V_{N}
Output
If there exists a matrix that satisfies the conditions, print one such matrix in the following format:
a_{1,1} ... a_{1,N}
:
a_{N,1} ... a_{N,N}
Note that any matrix satisfying the conditions is accepted.
If no matrix satisfies the conditions, print -1.
Examples
Input
2
0 1
1 0
1 1
1 0
Output
1 1
1 0
Input
2
1 1
1 0
15 15
15 11
Output
15 11
15 11
### Response
```cpp
#include <cstdio>
#include <cstring>
typedef unsigned long long int ull;
int N;
ull targetOfRow[505],targetOfCol[505];
ull opcatOfRow[505],opcatOfCol[505];
ull matrix[505][505];
int zeroCountOfRow[505],zeroCountOfCol[505];
bool check(){
//
for(int r=1;r<=N;r++){
ull androw=-1,orrow=0ull,andcol=androw,orcol=orrow;
for(int c=1;c<=N;c++){
androw&=matrix[r][c];
orrow|=matrix[r][c];
andcol&=matrix[c][r];
orcol|=matrix[c][r];
}
if (opcatOfRow[r]&&orrow!=targetOfRow[r]) return false;
if (!opcatOfRow[r]&&androw!=targetOfRow[r]) return false;
if (opcatOfCol[r]&&orcol!=targetOfCol[r]) return false;
if (!opcatOfCol[r]&&andcol!=targetOfCol[r]) return false;
}
return true;
}
void simpleInference(int pos){
for(int r=1;r<=N;r++){
for(int c=1;c<=N;c++){
//目標値の対応ビットを取り出す
auto colBit=(targetOfCol[c]>>pos)&1;
auto rowBit=(targetOfRow[r]>>pos)&1;
if (colBit^opcatOfCol[c]) matrix[r][c]|=(colBit<<pos);
if (rowBit^opcatOfRow[r]) matrix[r][c]|=(rowBit<<pos);
if (rowBit==colBit) matrix[r][c]|=(rowBit<<pos);
}
}
}
void SpecialInference(ull targets[],ull targets2[],ull ops1[],ull ops2[],int zeros1[],int zeros2[],bool isRow,int pos){
ull mask=(ull)1<<(ull)pos;
for(int r=1;r<=N;r++){
//今の桁を何にするかを表す
auto bitTarget=(targets[r]>>pos)&ops1[r];
if (!bitTarget||zeros1[r]<N) continue;
int c=1;
while(c<=N){
if (ops2[c]==0&&(targets2[c]&mask)==0&&zeros2[c]>1) break;
c++;
}
if (c>N) continue;
if (isRow)
matrix[r][c]|=mask;
else
matrix[c][r]|=mask;
zeros2[c]--;
zeros1[r]--;
}
}
int main(){
scanf("%d",&N);
for(int i=1;i<=N;i++) scanf("%llu",opcatOfRow+i);
for(int i=1;i<=N;i++) scanf("%llu",opcatOfCol+i);
for(int i=1;i<=N;i++) scanf("%llu",targetOfRow+i);
for(int i=1;i<=N;i++) scanf("%llu",targetOfCol+i);
for(int bit=0;bit<64;bit++){
ull mask=(ull)1<<(ull)bit;
simpleInference(bit);
memset(zeroCountOfCol,0,sizeof(zeroCountOfCol));
memset(zeroCountOfRow,0,sizeof(zeroCountOfRow));
for(int r=1;r<=N;r++)
for(int w=1;w<=N;w++)
if ((mask&matrix[r][w])==0) zeroCountOfRow[r]++,zeroCountOfCol[w]++;
SpecialInference(targetOfRow,targetOfCol,opcatOfRow,opcatOfCol,zeroCountOfRow,zeroCountOfCol,true,bit);
SpecialInference(targetOfCol,targetOfRow,opcatOfCol,opcatOfRow,zeroCountOfCol,zeroCountOfRow,false,bit);
// for(int r=1;r<=N;r++){
// //今の桁を何にするかを表す
// auto bitTarget=(targetOfRow[r]>>bit)&opcatOfRow[r];
// if (!bitTarget||zeroCountOfRow[r]<N) continue;
// int c=1;
// while(c<=N){
// if (opcatOfCol[c]==0&&(targetOfCol[c]&mask)==0&&zeroCountOfCol[c]>1) break;
// c++;
// }
// if (c>N) continue;
// matrix[r][c]|=mask;
// zeroCountOfCol[c]--;
// zeroCountOfRow[r]--;
// }
// for(int c=1;c<=N;c++){
// //今の桁を何にするかを表す
// auto bitTarget=(targetOfCol[c]>>bit)&opcatOfCol[c];
// if (!bitTarget||zeroCountOfCol[c]<N) continue;
// int r=1;
// while(r<=N) {
// if (opcatOfRow[r]==0&&(targetOfRow[r]&mask)==0&&zeroCountOfRow[r]>1) break;
// r++;
// }
// if (r>N) continue;
// matrix[r][c]|=mask;
// zeroCountOfCol[c]--;
// zeroCountOfRow[r]--;
// }
}
if (!check()){
puts("-1");
return 0;
}
for(int i=1;i<=N;i++){
for(int j=1;j<=N;j++)
printf("%llu ",matrix[i][j]);
putchar('\n');
}
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
Do you know "sed," a tool provided with Unix? Its most popular use is to substitute every occurrence of a string contained in the input string (actually each input line) with another string β. More precisely, it proceeds as follows.
1. Within the input string, every non-overlapping (but possibly adjacent) occurrences of α are marked. If there is more than one possibility for non-overlapping matching, the leftmost one is chosen.
2. Each of the marked occurrences is substituted with β to obtain the output string; other parts of the input string remain intact.
For example, when α is "aa" and β is "bca", an input string "aaxaaa" will produce "bcaxbcaa", but not "aaxbcaa" nor "bcaxabca". Further application of the same substitution to the string "bcaxbcaa" will result in "bcaxbcbca", but this is another substitution, which is counted as the second one.
In this problem, a set of substitution pairs (αi, βi) (i = 1, 2, ... , n), an initial string γ, and a final string δ are given, and you must investigate how to produce δ from γ with a minimum number of substitutions. A single substitution (αi, βi) here means simultaneously substituting all the non-overlapping occurrences of αi, in the sense described above, with βi.
You may use a specific substitution (αi, βi ) multiple times, including zero times.
Input
The input consists of multiple datasets, each in the following format.
n
α1 β1
α2 β2
.
.
.
αn βn
γ δ
n is a positive integer indicating the number of pairs. αi and βi are separated by a single space. You may assume that 1 ≤ |αi| < |βi| ≤ 10 for any i (|s| means the length of the string s), αi ≠ αj for any i ≠ j, n ≤ 10 and 1 ≤ |γ| < |δ| ≤ 10. All the strings consist solely of lowercase letters. The end of the input is indicated by a line containing a single zero.
Output
For each dataset, output the minimum number of substitutions to obtain δ from γ. If δ cannot be produced from γ with the given set of substitutions, output -1.
Example
Input
2
a bb
b aa
a
bbbbbbbb
1
a aa
a
aaaaa
3
ab aab
abc aadc
ad dee
abc
deeeeeeeec
10
a abc
b bai
c acf
d bed
e abh
f fag
g abe
h bag
i aaj
j bbb
a
abacfaabe
0
Output
3
-1
7
4
### Response
```cpp
#include<bits/stdc++.h>
#define r(i,n) for(int i=0;i<n;i++)
#define mk make_pair
using namespace std;
int main(){
int n;
while(cin>>n,n){
set<string>se;
string s,t,w1,w2;
string m[n][2];
r(i,n)cin>>m[i][0]>>m[i][1];
cin>>s>>t;
queue<pair<string,int> >q;
q.push(mk(s,0));
se.insert(s);
while(!q.empty()){
pair<string,int>p=q.front();q.pop();
string tt=p.first;
if(tt==t){cout<<p.second<<endl;goto L;}
for(int i=0;i<n;i++){
string g,x;
for(int j=0;j<tt.size();j++){
string y;
int hh=0;
for(int k=j;k<tt.size()+1;k++){
if(y==m[i][0]){hh++;j=k-1;break;}
if(k>=tt.size())break;
y+=tt[k];
}
if(!hh)g+=tt[j];
else g+=m[i][1];
}
if(!se.count(g)&&g.size()<=t.size()){
q.push(mk(g,p.second+1));
se.insert(g);
}
}
}
cout<<-1<<endl;L:;
}
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
Alice wants to send an email to Miku on her mobile phone.
The only buttons that can be used for input on mobile phones are number buttons. Therefore, in order to input characters, the number buttons are pressed several times to input characters. The following characters are assigned to the number buttons of the mobile phone, and the confirmation button is assigned to button 0. With this mobile phone, you are supposed to press the confirm button after you finish entering one character.
* 1:.,!? (Space)
* 2: a b c
* 3: d e f
* 4: g h i
* 5: j k l
* 6: m n o
* 7: p q r s
* 8: t u v
* 9: w x y z
* 0: Confirm button
For example, if you press button 2, button 2, or button 0, the letter changes from'a'to'b', and the confirm button is pressed here, so the letter b is output. If you enter the same number in succession, the changing characters will loop. That is, if you press button 2 five times and then button 0, the letters change from'a'→' b'→'c' →'a' →'b', and the confirm button is pressed here. 'b' is output.
You can press the confirm button when no button is pressed, but in that case no characters are output.
Your job is to recreate the message Alice created from a row of buttons pressed by Alice.
Input
The first line gives the number of test cases. Each test case is then given a string of digits up to 1024 in length in one row.
Output
Print the string of Alice's message line by line for each test case. However, you can assume that the output is one or more and less than 76 characters.
Example
Input
5
20
220
222220
44033055505550666011011111090666077705550301110
000555555550000330000444000080000200004440000
Output
a
b
b
hello, world!
keitai
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
string table[]={"",".,!? ","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"};
char str[1280];
int a;
cin>>a;
for(int i=0;i<a;i++){
cin>>str;
int r=0;
char now='0';
for(int i=0;str[i];i++){
if(now!=str[i]){
if(now!='0'){
cout<<table[now-'0'][(r-1)%table[now-'0'].size()];
}
r=1;
now=str[i];
}else r++;
}
cout<<endl;
}
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
Petya sometimes has to water his field. To water the field, Petya needs a tank with exactly V ml of water.
Petya has got N tanks, i-th of them initially containing ai ml of water. The tanks are really large, any of them can contain any amount of water (no matter how large this amount is).
Also Petya has got a scoop that can contain up to K ml of water (initially the scoop is empty). This scoop can be used to get some water from some tank, and after that pour it all into some tank (it is impossible to get water from multiple tanks without pouring it, or leave some water in the scoop when pouring it). When Petya tries to get some water from a tank, he gets min(v, K) water, where v is the current volume of water in the tank.
Is it possible to obtain a tank with exactly V ml of water using these operations? If it is possible, print a sequence of operations that allows to do it. If there are multiple ways to obtain needed amount of water in some tank, print any of them.
Input
The first line contains 3 integers: N (2 ≤ N ≤ 5000), K (1 ≤ K ≤ 5000), and V (0 ≤ V ≤ 109) — the number of tanks, the maximum volume of water the scoop can contain, and the required amount of water in some tank, respectively.
The second line contains N integers ai (0 ≤ ai ≤ 105), where ai is initial volume of water in i-th tank.
Output
If it is impossible to obtain a tank with exactly V ml of water, print NO.
Otherwise print YES in the first line, and beginning from the second line, print the sequence of operations in the following format:
Each line has to contain 3 numbers denoting a compressed operation: "cnt x y" (1 ≤ cnt ≤ 109, 1 ≤ x, y ≤ N), where x is the index of the tank where we get water, y is the index of the tank where we pour water, and cnt is the number of times we transfer water from tank x to tank y.
The number of these lines must not exceed N + 5.
Examples
Input
2 3 5
2 3
Output
YES
1 2 1
Input
2 3 4
2 3
Output
NO
Input
5 2 0
1 3 5 7 9
Output
YES
2 2 1
3 3 1
4 4 1
5 5 1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 5005;
const int inf = 1e9;
void dao(int x, int y, int z) {
if (x) printf("%d %d %d\n", x, y, z);
}
int n, k, v, a[N], b[N];
bool f[N][N], g[N][N];
int main() {
int i, j, t, r, s = 0;
scanf("%d%d%d", &n, &k, &v);
for (i = 1; i <= n; i = i + 1) scanf("%d", a + i), s += a[i];
if (s < v) {
printf("NO\n");
return 0;
}
if (v % k == 0) {
printf("YES\n");
for (i = 2; i <= n; i = i + 1)
if (a[i]) dao((a[i] - 1) / k + 1, i, 1);
dao(v / k, 1, 2);
return 0;
}
f[0][0] = 1;
for (i = 1; i <= n; i = i + 1)
for (j = 0; j < k; j = j + 1) {
if (f[i - 1][j]) f[i][j] = 1, g[i][j] = 0;
if (f[i - 1][(j - a[i] % k + k) % k]) f[i][j] = 1, g[i][j] = 1;
}
if (!f[n][v % k]) {
printf("NO\n");
return 0;
}
j = v % k;
for (i = n; i >= 1; i = i - 1) {
if (g[i][j])
b[i] = 1, t = i, j = (j - a[i] % k + k) % k;
else
b[i] = 0, r = i;
}
printf("YES\n");
s = a[t];
for (i = 1; i <= n; i = i + 1)
if (a[i] && b[i] && i != t) dao((a[i] - 1) / k + 1, i, t), r = i, s += a[i];
for (i = 1; i <= n; i = i + 1)
if (a[i] && !b[i] && i != r) dao((a[i] - 1) / k + 1, i, r);
if (s >= v)
dao((s - v) / k, t, r);
else
dao((v - s) / k, r, t);
return 0;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
Problem statement
There is a tree consisting of $ N $ vertices $ N-1 $ edges, and the $ i $ th edge connects the $ u_i $ and $ v_i $ vertices.
Each vertex has a button, and the button at the $ i $ th vertex is called the button $ i $.
First, the beauty of the button $ i $ is $ a_i $.
Each time you press the button $ i $, the beauty of the button $ i $ is given to the adjacent buttons by $ 1 $.
That is, if the $ i $ th vertex is adjacent to the $ c_1, ..., c_k $ th vertex, the beauty of the button $ i $ is reduced by $ k $, and the button $ c_1, ..., The beauty of c_k $ increases by $ 1 $ each.
At this time, you may press the button with negative beauty, or the beauty of the button as a result of pressing the button may become negative.
Your goal is to make the beauty of buttons $ 1, 2, ..., N $ $ b_1, ..., b_N $, respectively.
How many times in total can you press the button to achieve your goal?
Constraint
* All inputs are integers
* $ 1 \ leq N \ leq 10 ^ 5 $
* $ 1 \ leq u_i, v_i \ leq N $
* $ -1000 \ leq a_i, b_i \ leq 1000 $
* $ \ sum_i a_i = \ sum_i b_i $
* The graph given is a tree
* The purpose can always be achieved with the given input
* * *
input
Input is given from standard input in the following format.
$ N $
$ u_1 $ $ v_1 $
$ \ vdots $
$ u_ {N-1} $ $ v_ {N-1} $
$ a_1 $ $ a_2 $ $ ... $ $ a_N $
$ b_1 $ $ b_2 $ $ ... $ $ b_N $
output
Output the minimum total number of button presses to achieve your goal.
* * *
Input example 1
Four
1 2
13
3 4
0 3 2 0
-3 4 5 -1
Output example 1
Four
You can achieve your goal by pressing the button a total of $ 4 $ times as follows, which is the minimum.
* Press the $ 1 $ button $ 2 $ times. The beauty of the buttons $ 1, 2, 3, 4 $ changes to $ -4, 5, 4, 0 $, respectively.
* Press the $ 2 $ button $ 1 $ times. Beauty changes to $ -3, 4, 4, 0 $ respectively.
* Press the $ 4 $ button $ 1 $ times. Beauty changes to $ -3, 4, 5, -1 $ respectively.
* * *
Input example 2
Five
1 2
13
3 4
3 5
-9 5 7 1 8
-7 4 5 1 9
Output example 2
3
Example
Input
4
1 2
1 3
3 4
0 3 2 0
-3 4 5 -1
Output
4
### Response
```cpp
#include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <climits>
#include <cmath>
#include <complex>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <iomanip>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include <cstdint>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef pair<int,int> pii;
#define MP make_pair
#define PB push_back
#define inf 1000000007
#define rep(i,n) for(int i = 0; i < (int)(n); ++i)
#define all(x) (x).begin(),(x).end()
template<typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val){
std::fill( (T*)array, (T*)(array+N), val );
}
template<class T> inline bool chmax(T &a, T b){
if(a<b){
a = b;
return true;
}
return false;
}
template<class T> inline bool chmin(T &a, T b){
if(a>b){
a = b;
return true;
}
return false;
}
vector<vector<int> > g;
vector<ll> c;
vector<ll> sub;
int n;
pair<ll,ll> dfs(int id,int pre){
ll mi = 0;
ll sm = 0;
map<int,ll> mp;
for(auto x:g[id]){
if(x!=pre){
auto y = dfs(x,id);
chmin(mi,y.first);
sm += y.second;
sub[id] += sub[x];
}
}
sub[id]++;
sm += -mi;
ll cc = -mi;
c[id] -= (ll)cc*(ll)g[id].size();
if(pre!=-1){
c[pre] += cc;
}
for(auto x:g[id]){
if(x!=pre){
c[x] += cc;
}
}
for(auto x:g[id]){
if(x!=pre){
if(c[x]>0){
sm += c[x]*sub[x];
c[id] += c[x];
c[x] = 0;
}
}
}
if(c[id]>0){
sm += sub[id]*c[id];
c[pre] += c[id];
c[id] = 0;
}
return MP(c[id],sm);
}
int main(){
cin >> n;
vector<int>a(n);
vector<int>b(n);
sub.resize(n);
g.resize(n);
c.resize(n);
rep(i,n-1){
int s,t;
cin >> s >> t;
s--;t--;
g[s].push_back(t);
g[t].push_back(s);
}
rep(i,n)cin >> a[i];
rep(i,n)cin >> b[i];
rep(i,n)c[i] = a[i]-b[i];
auto x = dfs(0,-1);
cout << x.second << endl;
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Decimal numbers are a common notation system currently in use and use ten symbols 0, 1, 2, 3, 4, 5, 6, 7, 8, and 9 to represent all numbers.
Binary numbers are a popular notation in the computer world and use two symbols, 0 and 1, to represent all numbers.
Only the four numbers 0, 1, 2, and 3 are used in quaternary numbers. In quaternary numbers, when the number is incremented from 0, it will be carried to the next digit when it reaches 4. Therefore, the decimal number 4 is carried to the expression "10".
Decimal | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | ...
--- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |- ---
Binary | 0 | 1 | 10 | 11 | 100 | 101 | 110 | 111 | 1000 | 101 | 1010 | ...
Quadrant | 0 | 1 | 2 | 3 | 10 | 11 | 12 | 13 | 20 | 21 | 22 | ...
In Hawaii, fish and taro were counted between fingers in the old days, so it seems that they used quaternary numbers instead of decimal numbers.
Create a program that converts the integer n input in decimal to decimal and outputs it.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of -1. One integer n (0 ≤ n ≤ 1000000) is given on one row for each dataset.
The number of datasets does not exceed 2000.
Output
The result of conversion to quaternary number for each input data set is output on one line.
Example
Input
7
4
0
12
10
10000
-1
Output
13
10
0
30
22
2130100
### Response
```cpp
#include <cstdio>
#include <algorithm>
using namespace std;
int quad[100];
void decToQuad(int n) {
if (n == 0) { printf("0\n"); return; }
int idx = 0;
while (n > 0) {
quad[idx++] = n%4;
n /= 4;
}
for (int i = idx -1; i >= 0; i--) printf("%d", quad[i]);
printf("\n");
}
int main()
{
int n;
for (; ;) {
scanf("%d", &n);
if (n == -1) break;
decToQuad(n);
}
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
We all know the impressive story of Robin Hood. Robin Hood uses his archery skills and his wits to steal the money from rich, and return it to the poor.
There are n citizens in Kekoland, each person has ci coins. Each day, Robin Hood will take exactly 1 coin from the richest person in the city and he will give it to the poorest person (poorest person right after taking richest's 1 coin). In case the choice is not unique, he will select one among them at random. Sadly, Robin Hood is old and want to retire in k days. He decided to spend these last days with helping poor people.
After taking his money are taken by Robin Hood richest person may become poorest person as well, and it might even happen that Robin Hood will give his money back. For example if all people have same number of coins, then next day they will have same number of coins too.
Your task is to find the difference between richest and poorest persons wealth after k days. Note that the choosing at random among richest and poorest doesn't affect the answer.
Input
The first line of the input contains two integers n and k (1 ≤ n ≤ 500 000, 0 ≤ k ≤ 109) — the number of citizens in Kekoland and the number of days left till Robin Hood's retirement.
The second line contains n integers, the i-th of them is ci (1 ≤ ci ≤ 109) — initial wealth of the i-th person.
Output
Print a single line containing the difference between richest and poorest peoples wealth.
Examples
Input
4 1
1 1 4 2
Output
2
Input
3 1
2 2 2
Output
0
Note
Lets look at how wealth changes through day in the first sample.
1. [1, 1, 4, 2]
2. [2, 1, 3, 2] or [1, 2, 3, 2]
So the answer is 3 - 1 = 2
In second sample wealth will remain the same for each person.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n;
long long int k;
vector<long long int> v;
vector<long long int> sum;
vector<long long int> tmp_sum;
long long int cnt(long long int L) {
int id = upper_bound(v.begin(), v.end(), L) - v.begin();
int cnt = id;
long long int S = (long long int)(cnt)*L;
id--;
if (id >= 0) {
S -= tmp_sum[id];
}
return S;
}
long long int cnt2(long long int L) {
int id = upper_bound(v.begin(), v.end(), L) - v.begin();
if (id == v.size()) return 0;
long long int S = (long long int)(v.size() - id) * L;
S = sum[id] - S;
return S;
}
long long int f(long long int mid) { return abs(cnt2(mid) - cnt(mid)); }
int main() {
scanf("%d%lld", &n, &k);
for (int i = 0; i < n; i++) {
long long int a;
scanf("%lld", &a);
v.push_back(a);
}
sort(v.begin(), v.end());
long long int mint = v[0];
long long int maxt = v.back();
if (mint == maxt) {
puts("0");
return 0;
}
sum = v;
for (int i = 1; i < sum.size(); i++) {
sum[i] += sum[i - 1];
}
tmp_sum = sum;
while (mint + 1LL < maxt) {
long long mid = (mint + maxt) >> 1LL;
if (cnt(mid) > k) {
maxt = mid;
} else {
mint = mid;
}
}
long long int __LEF = mint;
if (cnt(maxt) <= k) {
__LEF = maxt;
}
for (int i = 0; i < v.size(); i++) {
sum[i] = 0;
}
for (int i = v.size() - 1; i >= 0; i--) {
sum[i] = v[i];
if (i + 1 < sum.size()) {
sum[i] += sum[i + 1];
}
}
mint = v[0];
maxt = v.back();
while (mint + 1LL < maxt) {
long long int mid = (mint + maxt) >> 1LL;
if (cnt2(mid) > k) {
mint = mid;
} else {
maxt = mid;
}
}
long long int __RIG = maxt;
if (cnt2(mint) <= k) {
__RIG = mint;
}
if (__LEF < __RIG) {
printf("%lld\n", __RIG - __LEF);
return 0;
}
if (v.size() % 2) {
long long int mid = v[(v.size()) / 2];
int idd = -1;
for (int i = 0; i < v.size(); i++) {
if (v[i] != mid) {
idd = i;
break;
}
}
int iddd = v.size();
for (int i = v.size() - 1; i >= 0; i--) {
if (v[i] != mid) {
iddd = i;
break;
}
}
if (idd + 1 == v.size() - iddd) {
if (cnt(mid - 1) == cnt2(mid + 1)) {
puts("0");
return 0;
}
}
puts("1");
return 0;
} else {
long long int mint = 0;
long long int maxt = v.back();
while (mint + 2LL < maxt) {
long long int mid = (maxt - mint) / 3LL + mint;
long long int mid2 = 2LL * (maxt - mint) / 3LL + mint;
if (f(mid) < f(mid2)) {
maxt = mid2;
} else {
mint = mid;
}
}
long long int MM = LLONG_MAX;
while (mint <= maxt) {
MM = min(MM, f(mint));
mint++;
}
if (MM == 0LL) {
puts("0");
} else {
puts("1");
}
}
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
There is a grid of square cells with H horizontal rows and W vertical columns. The cell at the i-th row and the j-th column will be denoted as Cell (i, j).
In Cell (i, j), a_{ij} coins are placed.
You can perform the following operation any number of times:
Operation: Choose a cell that was not chosen before and contains one or more coins, then move one of those coins to a vertically or horizontally adjacent cell.
Maximize the number of cells containing an even number of coins.
Constraints
* All values in input are integers.
* 1 \leq H, W \leq 500
* 0 \leq a_{ij} \leq 9
Input
Input is given from Standard Input in the following format:
H W
a_{11} a_{12} ... a_{1W}
a_{21} a_{22} ... a_{2W}
:
a_{H1} a_{H2} ... a_{HW}
Output
Print a sequence of operations that maximizes the number of cells containing an even number of coins, in the following format:
N
y_1 x_1 y_1' x_1'
y_2 x_2 y_2' x_2'
:
y_N x_N y_N' x_N'
That is, in the first line, print an integer N between 0 and H \times W (inclusive), representing the number of operations.
In the (i+1)-th line (1 \leq i \leq N), print four integers y_i, x_i, y_i' and x_i' (1 \leq y_i, y_i' \leq H and 1 \leq x_i, x_i' \leq W), representing the i-th operation. These four integers represents the operation of moving one of the coins placed in Cell (y_i, x_i) to a vertically or horizontally adjacent cell, (y_i', x_i').
Note that if the specified operation violates the specification in the problem statement or the output format is invalid, it will result in Wrong Answer.
Examples
Input
2 3
1 2 3
0 1 1
Output
3
2 2 2 3
1 1 1 2
1 3 1 2
Input
3 2
1 0
2 1
1 0
Output
3
1 1 1 2
1 2 2 2
3 1 3 2
Input
1 5
9 9 9 9 9
Output
2
1 1 1 2
1 3 1 4
### Response
```cpp
#include<iostream>
#include<algorithm>
#include<string>
#include<sstream>
using namespace std;
int main() {
int h,w;
cin >> h >> w;;
int** a = new int*[500];
stringstream ans;
int counter = 0;
for(int i=0;i<h;i++){
a[i] = new int[500];
for(int j=0;j<w;j++){
cin >> a[i][j];
}
}
for(int i=0;i<h;i++){
for(int j=0;j<w-1;j++){
if(a[i][j]%2==1){
counter++;
ans << i+1 << " " << j+1 << " " << i+1 << " " << j+2 << endl;
a[i][j+1] += 1;
}
}
}
for(int i=0;i<h-1;i++){
if(a[i][w-1]%2==1){
counter++;
ans << i+1 << " " << w << " " << i+2 << " " << w << endl;
a[i+1][w-1] += 1;
}
}
cout << counter << endl;
cout << ans.str();
return 0;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
Berland Football Cup starts really soon! Commentators from all over the world come to the event.
Organizers have already built n commentary boxes. m regional delegations will come to the Cup. Every delegation should get the same number of the commentary boxes. If any box is left unoccupied then the delegations will be upset. So each box should be occupied by exactly one delegation.
If n is not divisible by m, it is impossible to distribute the boxes to the delegations at the moment.
Organizers can build a new commentary box paying a burles and demolish a commentary box paying b burles. They can both build and demolish boxes arbitrary number of times (each time paying a corresponding fee). It is allowed to demolish all the existing boxes.
What is the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m)?
Input
The only line contains four integer numbers n, m, a and b (1 ≤ n, m ≤ 10^{12}, 1 ≤ a, b ≤ 100), where n is the initial number of the commentary boxes, m is the number of delegations to come, a is the fee to build a box and b is the fee to demolish a box.
Output
Output the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m). It is allowed that the final number of the boxes is equal to 0.
Examples
Input
9 7 3 8
Output
15
Input
2 7 3 7
Output
14
Input
30 6 17 19
Output
0
Note
In the first example organizers can build 5 boxes to make the total of 14 paying 3 burles for the each of them.
In the second example organizers can demolish 2 boxes to make the total of 0 paying 7 burles for the each of them.
In the third example organizers are already able to distribute all the boxes equally among the delegations, each one get 5 boxes.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int inf = INT_MAX;
const long long int infl = LLONG_MAX;
long long int n, i, j, k, m, a, b;
int main() {
cin >> n >> m >> a >> b;
long long int x = n % m;
long long int cost2 = x * b;
long long int cost1 = (m - x) * a;
cout << min(cost1, cost2);
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
Nastya came to her informatics lesson, and her teacher who is, by the way, a little bit famous here gave her the following task.
Two matrices A and B are given, each of them has size n × m. Nastya can perform the following operation to matrix A unlimited number of times:
* take any square square submatrix of A and transpose it (i.e. the element of the submatrix which was in the i-th row and j-th column of the submatrix will be in the j-th row and i-th column after transposing, and the transposed submatrix itself will keep its place in the matrix A).
Nastya's task is to check whether it is possible to transform the matrix A to the matrix B.
<image> Example of the operation
As it may require a lot of operations, you are asked to answer this question for Nastya.
A square submatrix of matrix M is a matrix which consist of all elements which comes from one of the rows with indeces x, x+1, ..., x+k-1 of matrix M and comes from one of the columns with indeces y, y+1, ..., y+k-1 of matrix M. k is the size of square submatrix. In other words, square submatrix is the set of elements of source matrix which form a solid square (i.e. without holes).
Input
The first line contains two integers n and m separated by space (1 ≤ n, m ≤ 500) — the numbers of rows and columns in A and B respectively.
Each of the next n lines contains m integers, the j-th number in the i-th of these lines denotes the j-th element of the i-th row of the matrix A (1 ≤ A_{ij} ≤ 10^{9}).
Each of the next n lines contains m integers, the j-th number in the i-th of these lines denotes the j-th element of the i-th row of the matrix B (1 ≤ B_{ij} ≤ 10^{9}).
Output
Print "YES" (without quotes) if it is possible to transform A to B and "NO" (without quotes) otherwise.
You can print each letter in any case (upper or lower).
Examples
Input
2 2
1 1
6 1
1 6
1 1
Output
YES
Input
2 2
4 4
4 5
5 4
4 4
Output
NO
Input
3 3
1 2 3
4 5 6
7 8 9
1 4 7
2 5 6
3 8 9
Output
YES
Note
Consider the third example. The matrix A initially looks as follows.
$$$ \begin{bmatrix} 1 & 2 & 3\\\ 4 & 5 & 6\\\ 7 & 8 & 9 \end{bmatrix} $$$
Then we choose the whole matrix as transposed submatrix and it becomes
$$$ \begin{bmatrix} 1 & 4 & 7\\\ 2 & 5 & 8\\\ 3 & 6 & 9 \end{bmatrix} $$$
Then we transpose the submatrix with corners in cells (2, 2) and (3, 3).
$$$ \begin{bmatrix} 1 & 4 & 7\\\ 2 & 5 & 8\\\ 3 & 6 & 9 \end{bmatrix} $$$
So matrix becomes
$$$ \begin{bmatrix} 1 & 4 & 7\\\ 2 & 5 & 6\\\ 3 & 8 & 9 \end{bmatrix} $$$
and it is B.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long MOD = (long long)1e9 + 7;
int n, m;
vector<int> vec[2][1100];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int k = 0; k < 2; k++) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int tmp = i + j, x;
cin >> x;
vec[k][tmp].push_back(x);
}
}
}
for (int i = 0; i < n + m; i++) {
sort(vec[0][i].begin(), vec[0][i].end());
sort(vec[1][i].begin(), vec[1][i].end());
int len = vec[0][i].size();
for (int j = 0; j < len; j++) {
if (vec[0][i][j] != vec[1][i][j]) {
cout << "NO\n";
return 0;
}
}
}
cout << "YES\n";
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
Arkady wants to have a dinner. He has just returned from a shop where he has bought a semifinished cutlet. He only needs to fry it. The cutlet should be fried for 2n seconds, in particular, it should be fried for n seconds on one side and n seconds on the other side. Arkady has already got a frying pan and turn on fire, but understood that maybe he won't be able to flip the cutlet exactly after n seconds after the beginning of cooking.
Arkady is too busy with sorting sticker packs in his favorite messenger and can flip the cutlet only in some periods of time. Namely, there are k periods of time in which he can do it, the i-th of them is an interval of time from li seconds after he starts cooking till ri seconds, inclusive. Arkady decided that it's not required to flip the cutlet exactly in the middle of cooking, instead, he will flip it several times in such a way that the cutlet will be fried exactly n seconds on one side and n seconds on the other side in total.
Help Arkady and find out if it's possible for him to cook the cutlet, if he is able to flip the cutlet only in given periods of time; and if yes, find the minimum number of flips he needs to cook the cutlet.
Input
The first line contains two integers n and k (1 ≤ n ≤ 100 000, 1 ≤ k ≤ 100) — the number of seconds the cutlet should be cooked on each side and number of periods of time in which Arkady can flip it.
The next k lines contain descriptions of these intervals. Each line contains two integers li and ri (0 ≤ li ≤ ri ≤ 2·n), meaning that Arkady can flip the cutlet in any moment starting from li seconds after the beginning of cooking and finishing at ri seconds after beginning of cooking. In particular, if li = ri then Arkady can flip the cutlet only in the moment li = ri. It's guaranteed that li > ri - 1 for all 2 ≤ i ≤ k.
Output
Output "Hungry" if Arkady won't be able to fry the cutlet for exactly n seconds on one side and exactly n seconds on the other side.
Otherwise, output "Full" in the first line, and the minimum number of times he should flip the cutlet in the second line.
Examples
Input
10 2
3 5
11 13
Output
Full
2
Input
10 3
3 5
9 10
11 13
Output
Full
1
Input
20 1
3 19
Output
Hungry
Note
In the first example Arkady should flip the cutlet in time moment 3 seconds after he starts cooking and in time moment 13 seconds after he starts cooking.
In the second example, Arkady can flip the cutlet at 10 seconds after he starts cooking.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 30;
const int BUF = 100005;
const int RANGE = 105;
int leng, nRange;
int range[RANGE][2];
void read() {
cin >> leng >> nRange;
for (int i = 0; i < nRange; ++i) {
cin >> range[i][0] >> range[i][1];
}
}
void work() {
int dp[2][BUF];
for (int i = 0; i < 2; ++i) {
for (int j = 0; j <= leng; ++j) {
dp[i][j] = INF;
}
}
dp[0][0] = 0;
for (int rangeId = 0; rangeId < nRange; ++rangeId) {
int nextDp[2][BUF];
for (int i = 0; i < 2; ++i) {
for (int j = 0; j <= leng; ++j) {
nextDp[i][j] = INF;
}
}
int dt;
dt = range[rangeId][0] - (rangeId == 0 ? 0 : range[rangeId - 1][1]);
for (int i = 0; i <= leng; ++i) {
if (i >= dt) {
nextDp[0][i] = min(nextDp[0][i], dp[0][i - dt]);
}
nextDp[1][i] = min(nextDp[1][i], dp[1][i]);
}
for (int i = 0; i < 2; ++i) {
for (int j = 0; j <= leng; ++j) {
dp[i][j] = nextDp[i][j];
nextDp[i][j] = INF;
}
}
dt = range[rangeId][1] - range[rangeId][0];
deque<int> DQ[2];
for (int i = 0; i <= leng; ++i) {
while (DQ[0].size() > 0 && DQ[0].back() > dp[0][i]) DQ[0].pop_back();
DQ[0].push_back(dp[0][i]);
while (DQ[1].size() > 0 && DQ[1].back() > dp[1][i]) DQ[1].pop_back();
DQ[1].push_back(dp[1][i]);
if (i >= dt) {
nextDp[0][i] = min(nextDp[0][i], dp[0][i - dt]);
}
nextDp[1][i] = min(nextDp[1][i], dp[1][i]);
if (DQ[1].size() > 0) nextDp[0][i] = min(nextDp[0][i], DQ[1].front() + 1);
if (DQ[0].size() > 0) nextDp[1][i] = min(nextDp[1][i], DQ[0].front() + 1);
if (DQ[0].size() > 0) nextDp[0][i] = min(nextDp[0][i], DQ[0].front() + 2);
if (DQ[1].size() > 0) nextDp[1][i] = min(nextDp[1][i], DQ[1].front() + 2);
if (DQ[0].size() > 0 && i - dt >= 0 && DQ[0].front() == dp[0][i - dt])
DQ[0].pop_front();
if (DQ[1].size() > 0 && i - dt >= 0 && DQ[1].front() == dp[1][i - dt])
DQ[1].pop_front();
}
for (int i = 0; i < 2; ++i) {
for (int j = 0; j <= leng; ++j) {
dp[i][j] = nextDp[i][j];
}
}
}
int nextDp[2][BUF];
for (int i = 0; i < 2; ++i) {
for (int j = 0; j <= leng; ++j) {
nextDp[i][j] = INF;
}
}
int dt = leng * 2 - range[nRange - 1][1];
for (int i = 0; i <= leng; ++i) {
if (i >= dt) {
nextDp[0][i] = min(nextDp[0][i], dp[0][i - dt]);
}
nextDp[1][i] = min(nextDp[1][i], dp[1][i]);
}
for (int i = 0; i < 2; ++i) {
for (int j = 0; j <= leng; ++j) {
dp[i][j] = nextDp[i][j];
}
}
if (dp[0][leng] != INF || dp[1][leng] != INF) {
cout << "Full" << endl;
cout << min(dp[0][leng], dp[1][leng]) << endl;
} else {
cout << "Hungry" << endl;
}
}
int main() {
read();
work();
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
You get to work and turn on the computer. You start coding and give little thought to the RAM role in the whole process. In this problem your task is to solve one of the problems you encounter in your computer routine.
We'll consider the RAM as a sequence of cells that can contain data. Some cells already contain some data, some are empty. The empty cells form the so-called memory clusters. Thus, a memory cluster is a sequence of some consecutive empty memory cells.
You have exactly n memory clusters, the i-th cluster consists of ai cells. You need to find memory for m arrays in your program. The j-th array takes 2bj consecutive memory cells. There possibly isn't enough memory for all m arrays, so your task is to determine what maximum number of arrays can be located in the available memory clusters. Of course, the arrays cannot be divided between the memory clusters. Also, no cell can belong to two arrays.
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 106). The next line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109). The next line contains m integers b1, b2, ..., bm (1 ≤ 2bi ≤ 109).
Output
Print a single integer — the answer to the problem.
Examples
Input
5 3
8 4 3 2 2
3 2 2
Output
2
Input
10 6
1 1 1 1 1 1 1 1 1 1
0 0 0 0 0 0
Output
6
Note
In the first example you are given memory clusters with sizes 8, 4, 3, 2, 2 and arrays with sizes 8, 4, 4. There are few ways to obtain an answer equals 2: you can locate array with size 8 to the cluster with size 8, and one of the arrays with size 4 to the cluster with size 4. Another way is to locate two arrays with size 4 to the one cluster with size 8.
In the second example you are given 10 memory clusters with size 1 and 6 arrays with size 1. You can choose any 6 clusters and locate all given arrays to them.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m, foo;
const int oo = 1e9;
int p[33];
int a[1000000];
int st[222], cnt[33];
void pull(int idx) { st[idx] = min(st[idx + idx], st[idx + idx + 1]); }
int query(int idx, int l, int r, int i, int j) {
if (l > j || r < i) {
return oo;
}
if (l >= i && r <= j) {
return st[idx];
}
return min(query(idx + idx, l, (r + l) / 2, i, j),
query(idx + idx + 1, (r + l) / 2 + 1, r, i, j));
}
void update(int idx, int l, int r, int i, int j, int val) {
if (l > j || r < i) {
return;
}
if (l == r && l == i) {
cnt[l] += val;
if (cnt[l] == 0) {
st[idx] = oo;
} else {
st[idx] = l;
}
return;
}
update(idx + idx, l, (r + l) / 2, i, j, val);
update(idx + idx + 1, (r + l) / 2 + 1, r, i, j, val);
pull(idx);
}
void get(int x) {
int bit = 0;
while (x) {
if (x & 1) {
if (cnt[bit]) {
cnt[bit]++;
} else {
update(1, 0, 30, bit, bit, 1);
}
}
x >>= 1;
bit++;
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < 222; i++) {
st[i] = oo;
}
for (int i = 0; i < n; i++) {
scanf("%d", &foo);
get(foo);
}
p[0] = 1;
for (int i = 1; i <= 30; i++) {
p[i] = p[i - 1] << 1;
}
for (int i = 0; i < m; i++) {
scanf("%d", &a[i]);
}
sort(a, a + m);
int ans = 0;
for (int i = 0; i < m; i++) {
int mn = query(1, 0, 30, a[i], 30);
if (mn == oo) {
break;
}
ans++;
update(1, 0, 30, mn, mn, -1);
if (mn > a[i]) {
get(p[mn] - p[a[i]]);
}
}
printf("%d\n", ans);
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Gerald has been selling state secrets at leisure. All the secrets cost the same: n marks. The state which secrets Gerald is selling, has no paper money, only coins. But there are coins of all positive integer denominations that are powers of three: 1 mark, 3 marks, 9 marks, 27 marks and so on. There are no coins of other denominations. Of course, Gerald likes it when he gets money without the change. And all buyers respect him and try to give the desired sum without change, if possible. But this does not always happen.
One day an unlucky buyer came. He did not have the desired sum without change. Then he took out all his coins and tried to give Gerald a larger than necessary sum with as few coins as possible. What is the maximum number of coins he could get?
The formal explanation of the previous paragraph: we consider all the possible combinations of coins for which the buyer can not give Gerald the sum of n marks without change. For each such combination calculate the minimum number of coins that can bring the buyer at least n marks. Among all combinations choose the maximum of the minimum number of coins. This is the number we want.
Input
The single line contains a single integer n (1 ≤ n ≤ 1017).
Please, do not use the %lld specifier to read or write 64 bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
In a single line print an integer: the maximum number of coins the unlucky buyer could have paid with.
Examples
Input
1
Output
1
Input
4
Output
2
Note
In the first test case, if a buyer has exactly one coin of at least 3 marks, then, to give Gerald one mark, he will have to give this coin. In this sample, the customer can not have a coin of one mark, as in this case, he will be able to give the money to Gerald without any change.
In the second test case, if the buyer had exactly three coins of 3 marks, then, to give Gerald 4 marks, he will have to give two of these coins. The buyer cannot give three coins as he wants to minimize the number of coins that he gives.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int te;
cin >> te;
long long int cg = 3;
long long int ans = 1;
while (cg < te) {
if (te % cg != 0) {
ans = te / cg;
ans++;
break;
} else
cg *= 3;
}
cout << ans << "\n";
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
Tomorrow is a difficult day for Polycarp: he has to attend a lectures and b practical classes at the university! Since Polycarp is a diligent student, he is going to attend all of them.
While preparing for the university, Polycarp wonders whether he can take enough writing implements to write all of the lectures and draw everything he has to during all of the practical classes. Polycarp writes lectures using a pen (he can't use a pencil to write lectures!); he can write down c lectures using one pen, and after that it runs out of ink. During practical classes Polycarp draws blueprints with a pencil (he can't use a pen to draw blueprints!); one pencil is enough to draw all blueprints during d practical classes, after which it is unusable.
Polycarp's pencilcase can hold no more than k writing implements, so if Polycarp wants to take x pens and y pencils, they will fit in the pencilcase if and only if x + y ≤ k.
Now Polycarp wants to know how many pens and pencils should he take. Help him to determine it, or tell that his pencilcase doesn't have enough room for all the implements he needs tomorrow!
Note that you don't have to minimize the number of writing implements (though their total number must not exceed k).
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases in the input. Then the test cases follow.
Each test case is described by one line containing five integers a, b, c, d and k, separated by spaces (1 ≤ a, b, c, d, k ≤ 100) — the number of lectures Polycarp has to attend, the number of practical classes Polycarp has to attend, the number of lectures which can be written down using one pen, the number of practical classes for which one pencil is enough, and the number of writing implements that can fit into Polycarp's pencilcase, respectively.
In hacks it is allowed to use only one test case in the input, so t = 1 should be satisfied.
Output
For each test case, print the answer as follows:
If the pencilcase can't hold enough writing implements to use them during all lectures and practical classes, print one integer -1. Otherwise, print two non-negative integers x and y — the number of pens and pencils Polycarp should put in his pencilcase. If there are multiple answers, print any of them. Note that you don't have to minimize the number of writing implements (though their total number must not exceed k).
Example
Input
3
7 5 4 5 8
7 5 4 5 2
20 53 45 26 4
Output
7 1
-1
1 3
Note
There are many different answers for the first test case; x = 7, y = 1 is only one of them. For example, x = 3, y = 1 is also correct.
x = 1, y = 3 is the only correct answer for the third test case.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (b == 0 || a == 0) return a + b;
return gcd(b, a % b);
}
const int inf = int(1e9);
const int mod = inf + 7;
void solve() {
int a, b, c, d, k;
cin >> a >> b >> c >> d >> k;
int x = a / c + (a % c != 0);
int y = b / d + (b % d != 0);
if (x + y > k)
cout << -1 << endl;
else
cout << x << " " << y << endl;
}
int main() {
int t = 1;
cin >> t;
while (t--) solve();
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
You are given an array a_1, a_2, …, a_n of integers. This array is non-increasing.
Let's consider a line with n shops. The shops are numbered with integers from 1 to n from left to right. The cost of a meal in the i-th shop is equal to a_i.
You should process q queries of two types:
* 1 x y: for each shop 1 ≤ i ≤ x set a_{i} = max(a_{i}, y).
* 2 x y: let's consider a hungry man with y money. He visits the shops from x-th shop to n-th and if he can buy a meal in the current shop he buys one item of it. Find how many meals he will purchase. The man can buy a meal in the shop i if he has at least a_i money, and after it his money decreases by a_i.
Input
The first line contains two integers n, q (1 ≤ n, q ≤ 2 ⋅ 10^5).
The second line contains n integers a_{1},a_{2}, …, a_{n} (1 ≤ a_{i} ≤ 10^9) — the costs of the meals. It is guaranteed, that a_1 ≥ a_2 ≥ … ≥ a_n.
Each of the next q lines contains three integers t, x, y (1 ≤ t ≤ 2, 1≤ x ≤ n, 1 ≤ y ≤ 10^9), each describing the next query.
It is guaranteed that there exists at least one query of type 2.
Output
For each query of type 2 output the answer on the new line.
Example
Input
10 6
10 10 10 6 6 5 5 5 3 1
2 3 50
2 4 10
1 3 10
2 2 36
1 4 7
2 2 17
Output
8
3
6
2
Note
In the first query a hungry man will buy meals in all shops from 3 to 10.
In the second query a hungry man will buy meals in shops 4, 9, and 10.
After the third query the array a_1, a_2, …, a_n of costs won't change and will be \{10, 10, 10, 6, 6, 5, 5, 5, 3, 1\}.
In the fourth query a hungry man will buy meals in shops 2, 3, 4, 5, 9, and 10.
After the fifth query the array a of costs will be \{10, 10, 10, 7, 6, 5, 5, 5, 3, 1\}.
In the sixth query a hungry man will buy meals in shops 2 and 4.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
inline long long rd() {
long long X = 0;
bool flag = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') flag = 0;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
X = (X << 1) + (X << 3) + ch - '0';
ch = getchar();
}
if (flag) return X;
return ~(X - 1);
}
const int N = 5e5 + 5, SZ = N << 2, INF = 0x7fffffff;
int n, m;
int a[N];
struct data {
int mx, mx2, mn, mn2, cmx, cmn, tmx, tmn, tad;
long long sum;
};
data t[SZ];
void pushup(int u) {
const int lu = u << 1, ru = u << 1 | 1;
t[u].sum = t[lu].sum + t[ru].sum;
if (t[lu].mx == t[ru].mx) {
t[u].mx = t[lu].mx, t[u].cmx = t[lu].cmx + t[ru].cmx;
t[u].mx2 = max(t[lu].mx2, t[ru].mx2);
} else if (t[lu].mx > t[ru].mx) {
t[u].mx = t[lu].mx, t[u].cmx = t[lu].cmx;
t[u].mx2 = max(t[lu].mx2, t[ru].mx);
} else {
t[u].mx = t[ru].mx, t[u].cmx = t[ru].cmx;
t[u].mx2 = max(t[lu].mx, t[ru].mx2);
}
if (t[lu].mn == t[ru].mn) {
t[u].mn = t[lu].mn, t[u].cmn = t[lu].cmn + t[ru].cmn;
t[u].mn2 = min(t[lu].mn2, t[ru].mn2);
} else if (t[lu].mn < t[ru].mn) {
t[u].mn = t[lu].mn, t[u].cmn = t[lu].cmn;
t[u].mn2 = min(t[lu].mn2, t[ru].mn);
} else {
t[u].mn = t[ru].mn, t[u].cmn = t[ru].cmn;
t[u].mn2 = min(t[lu].mn, t[ru].mn2);
}
}
void push_add(int u, int l, int r, int v) {
t[u].sum += (r - l + 1ll) * v;
t[u].mx += v, t[u].mn += v;
if (t[u].mx2 != -INF) t[u].mx2 += v;
if (t[u].mn2 != INF) t[u].mn2 += v;
if (t[u].tmx != -INF) t[u].tmx += v;
if (t[u].tmn != INF) t[u].tmn += v;
t[u].tad += v;
}
void push_min(int u, int tg) {
if (t[u].mx <= tg) return;
t[u].sum += (tg * 1ll - t[u].mx) * t[u].cmx;
if (t[u].mn2 == t[u].mx) t[u].mn2 = tg;
if (t[u].mn == t[u].mx) t[u].mn = tg;
if (t[u].tmx > tg) t[u].tmx = tg;
t[u].mx = tg, t[u].tmn = tg;
}
void push_max(int u, int tg) {
if (t[u].mn > tg) return;
t[u].sum += (tg * 1ll - t[u].mn) * t[u].cmn;
if (t[u].mx2 == t[u].mn) t[u].mx2 = tg;
if (t[u].mx == t[u].mn) t[u].mx = tg;
if (t[u].tmn < tg) t[u].tmn = tg;
t[u].mn = tg, t[u].tmx = tg;
}
void pushdown(int u, int l, int r) {
const int lu = u << 1, ru = u << 1 | 1, mid = (l + r) >> 1;
if (t[u].tad)
push_add(lu, l, mid, t[u].tad), push_add(ru, mid + 1, r, t[u].tad);
if (t[u].tmx != -INF) push_max(lu, t[u].tmx), push_max(ru, t[u].tmx);
if (t[u].tmn != INF) push_min(lu, t[u].tmn), push_min(ru, t[u].tmn);
t[u].tad = 0, t[u].tmx = -INF, t[u].tmn = INF;
}
void build(int u = 1, int l = 1, int r = n) {
t[u].tmn = INF, t[u].tmx = -INF;
if (l == r) {
t[u].sum = t[u].mx = t[u].mn = a[l];
t[u].mx2 = -INF, t[u].mn2 = INF;
t[u].cmx = t[u].cmn = 1;
return;
}
int mid = (l + r) >> 1;
build(u << 1, l, mid), build(u << 1 | 1, mid + 1, r);
pushup(u);
}
void add(int L, int R, int v, int u = 1, int l = 1, int r = n) {
if (R < l || r < L) return;
if (L <= l && r <= R) return push_add(u, l, r, v);
int mid = (l + r) >> 1;
pushdown(u, l, r);
add(L, R, v, u << 1, l, mid), add(L, R, v, u << 1 | 1, mid + 1, r);
pushup(u);
}
void tomax(int L, int R, int v, int u = 1, int l = 1, int r = n) {
if (R < l || r < L || t[u].mn >= v) return;
if (L <= l && r <= R && t[u].mn2 > v) return push_max(u, v);
int mid = (l + r) >> 1;
pushdown(u, l, r);
tomax(L, R, v, u << 1, l, mid), tomax(L, R, v, u << 1 | 1, mid + 1, r);
pushup(u);
}
long long qmin(int L, int R, int u = 1, int l = 1, int r = n) {
if (R < l || r < L) return INF;
if (L <= l && r <= R) return t[u].mn;
int mid = (l + r) >> 1;
pushdown(u, l, r);
return min(qmin(L, R, u << 1, l, mid), qmin(L, R, u << 1 | 1, mid + 1, r));
}
int y;
int bns(int l, int r) {
int res = -1;
while (l <= r) {
int md = l + r >> 1;
if (qmin(md, md) <= y)
res = md, r = md - 1;
else
l = md + 1;
}
return res;
}
long long qsum(int L, int R, int u = 1, int l = 1, int r = n) {
if (R < l || r < L) return 0;
int mid = (l + r) >> 1;
if (L <= l && r <= R) {
if (t[u].sum <= y && y > 0) {
y -= t[u].sum;
return r - l + 1;
} else {
pushdown(u, l, r);
if (t[u].mn > y) return 0;
return qsum(L, R, u << 1, l, mid) + qsum(L, R, u << 1 | 1, mid + 1, r);
}
}
pushdown(u, l, r);
return qsum(L, R, u << 1, l, mid) + qsum(L, R, u << 1 | 1, mid + 1, r);
}
int main() {
n = rd();
m = rd();
for (int i = 1; i <= n; i++) a[i] = rd();
build();
for (int i = 1; i <= m; i++) {
int op, l, x;
op = rd(), l = rd(), y = rd();
if (op == 1)
tomax(1, l, y);
else
printf("%lld\n", qsum(l, n));
}
return 0;
}
``` |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.