text
stringlengths 424
69.5k
|
|---|
### Prompt
Construct a Cpp code solution to the problem outlined:
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>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
int fa[300010], nxt[300010];
int find(int x) {
if (fa[x] != x) fa[x] = find(fa[x]);
return fa[x];
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) fa[i] = i, nxt[i] = i + 1;
while (m--) {
int op, a, b;
scanf("%d%d%d", &op, &a, &b);
if (a > b) swap(a, b);
if (op == 1) {
int u = find(a), v = find(b);
if (u == v) continue;
fa[u] = v;
} else if (op == 2) {
for (int i = a, j = nxt[i]; j <= b; i = j, j = nxt[i]) {
int u = find(i), v = find(j);
nxt[i] = nxt[j];
if (u == v) continue;
fa[u] = v;
}
} else {
if (find(a) == find(b))
puts("YES");
else
puts("NO");
}
}
return 0;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
Arthur and Alexander are number busters. Today they've got a competition.
Arthur took a group of four integers a, b, w, x (0 ≤ b < w, 0 < x < w) and Alexander took integer с. Arthur and Alexander use distinct approaches to number bustings. Alexander is just a regular guy. Each second, he subtracts one from his number. In other words, he performs the assignment: c = c - 1. Arthur is a sophisticated guy. Each second Arthur performs a complex operation, described as follows: if b ≥ x, perform the assignment b = b - x, if b < x, then perform two consecutive assignments a = a - 1; b = w - (x - b).
You've got numbers a, b, w, x, c. Determine when Alexander gets ahead of Arthur if both guys start performing the operations at the same time. Assume that Alexander got ahead of Arthur if c ≤ a.
Input
The first line contains integers a, b, w, x, c (1 ≤ a ≤ 2·109, 1 ≤ w ≤ 1000, 0 ≤ b < w, 0 < x < w, 1 ≤ c ≤ 2·109).
Output
Print a single integer — the minimum time in seconds Alexander needs to get ahead of Arthur. You can prove that the described situation always occurs within the problem's limits.
Examples
Input
4 2 3 1 6
Output
2
Input
4 2 3 1 7
Output
4
Input
1 2 3 2 6
Output
13
Input
1 1 2 1 1
Output
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long powmod(long long a, long long b) {
long long res = 1;
for (; b; b >>= 1) {
if (b & 1) res = res * a;
a = a * a;
}
return res;
}
int N, K;
long long a, b, w, x, C;
int in[2222];
int curMX;
bool check(long long mid) {
a -= (b + mid * x) / w;
C -= mid;
if (C <= a) return 1;
return 0;
}
long long _a, _b, _w, _x, _C;
int main() {
cin >> _a >> _b >> _w >> _x >> _C;
if (_C <= _a) {
cout << 0 << endl;
return 0;
}
long long low = -1, high = 200000000000001;
while (low + 1 < high) {
long long mid = (low + high) / 2;
a = _a, b = _b, w = _w, x = _x, C = _C;
b = w - b - 1;
if (check(mid)) {
high = mid;
} else
low = mid;
}
cout << high << endl;
return 0;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
One day two students, Grisha and Diana, found themselves in the university chemistry lab. In the lab the students found n test tubes with mercury numbered from 1 to n and decided to conduct an experiment.
The experiment consists of q steps. On each step, one of the following actions occurs:
1. Diana pours all the contents from tube number pi and then pours there exactly xi liters of mercury.
2. Let's consider all the ways to add vi liters of water into the tubes; for each way let's count the volume of liquid (water and mercury) in the tube with water with maximum amount of liquid; finally let's find the minimum among counted maximums. That is the number the students want to count. At that, the students don't actually pour the mercury. They perform calculations without changing the contents of the tubes.
Unfortunately, the calculations proved to be too complex and the students asked you to help them. Help them conduct the described experiment.
Input
The first line contains two integers n and q (1 ≤ n, q ≤ 105) — the number of tubes ans the number of experiment steps. The next line contains n space-separated integers: h1, h2, ..., hn (0 ≤ hi ≤ 109), where hi is the volume of mercury in the і-th tube at the beginning of the experiment.
The next q lines contain the game actions in the following format:
* A line of form "1 pi xi" means an action of the first type (1 ≤ pi ≤ n; 0 ≤ xi ≤ 109).
* A line of form "2 vi" means an action of the second type (1 ≤ vi ≤ 1015).
It is guaranteed that there is at least one action of the second type. It is guaranteed that all numbers that describe the experiment are integers.
Output
For each action of the second type print the calculated value. The answer will be considered correct if its relative or absolute error doesn't exceed 10 - 4.
Examples
Input
3 3
1 2 0
2 2
1 2 1
2 3
Output
1.50000
1.66667
Input
4 5
1 3 0 1
2 3
2 1
1 3 2
2 3
2 4
Output
1.66667
1.00000
2.33333
2.66667
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
class fenwick {
public:
long long int F[300000];
fenwick() { memset(F, 0, sizeof F); }
void update(int x, long long int val) {
while (x <= 250000) {
F[x] += val;
x += x & -x;
}
}
long long int query(int x) {
long long int res = 0;
while (x) {
res += F[x];
x -= x & -x;
}
return res;
}
} A, S;
int n, m;
long long int arr[200000];
map<long long int, int> yer;
pair<long long int, pair<long long int, long long int> > q[200000];
int f(double x) {
x -= 1e-8;
x = ceil(x);
return yer.lower_bound((long long int)x)->second;
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
scanf("%lld", arr + i);
yer[arr[i]] = 1;
}
for (int i = 1; i <= m; i++) {
scanf("%lld", &q[i].first);
if (q[i].first == 1) {
scanf("%lld %lld", &q[i].second.first, &q[i].second.second);
yer[q[i].second.second] = 1;
} else
scanf("%lld", &q[i].second.first);
}
int ind = 0;
for (typeof(yer.begin()) it = yer.begin(); it != yer.end(); it++)
it->second = ++ind;
yer[1e18] = ++ind;
for (int i = 1; i <= n; i++)
A.update(f(arr[i]), arr[i]), S.update(f(arr[i]), 1);
for (int i = 1; i <= m; i++) {
if (q[i].first == 1) {
A.update(f(arr[q[i].second.first]), -arr[q[i].second.first]),
S.update(f(arr[q[i].second.first]), -1);
arr[q[i].second.first] = q[i].second.second;
A.update(f(arr[q[i].second.first]), arr[q[i].second.first]),
S.update(f(arr[q[i].second.first]), 1);
} else {
double bas = 0.0, son = 1e18, orta;
for (int iteration = 1; iteration <= 200; iteration++) {
orta = (bas + son) / 2;
if (orta * S.query(f(orta) - 1) - A.query(f(orta) - 1) >=
q[i].second.first)
son = orta;
else
bas = orta;
}
printf("%.12lf\n", bas);
}
}
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
Bad news came to Mike's village, some thieves stole a bunch of chocolates from the local factory! Horrible!
Aside from loving sweet things, thieves from this area are known to be very greedy. So after a thief takes his number of chocolates for himself, the next thief will take exactly k times more than the previous one. The value of k (k > 1) is a secret integer known only to them. It is also known that each thief's bag can carry at most n chocolates (if they intend to take more, the deal is cancelled) and that there were exactly four thieves involved.
Sadly, only the thieves know the value of n, but rumours say that the numbers of ways they could have taken the chocolates (for a fixed n, but not fixed k) is m. Two ways are considered different if one of the thieves (they should be numbered in the order they take chocolates) took different number of chocolates in them.
Mike want to track the thieves down, so he wants to know what their bags are and value of n will help him in that. Please find the smallest possible value of n or tell him that the rumors are false and there is no such n.
Input
The single line of input contains the integer m (1 ≤ m ≤ 1015) — the number of ways the thieves might steal the chocolates, as rumours say.
Output
Print the only integer n — the maximum amount of chocolates that thieves' bags can carry. If there are more than one n satisfying the rumors, print the smallest one.
If there is no such n for a false-rumoured m, print - 1.
Examples
Input
1
Output
8
Input
8
Output
54
Input
10
Output
-1
Note
In the first sample case the smallest n that leads to exactly one way of stealing chocolates is n = 8, whereas the amounts of stealed chocolates are (1, 2, 4, 8) (the number of chocolates stolen by each of the thieves).
In the second sample case the smallest n that leads to exactly 8 ways is n = 54 with the possibilities: (1, 2, 4, 8), (1, 3, 9, 27), (2, 4, 8, 16), (2, 6, 18, 54), (3, 6, 12, 24), (4, 8, 16, 32), (5, 10, 20, 40), (6, 12, 24, 48).
There is no n leading to exactly 10 ways of stealing chocolates in the third sample case.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long m;
cin >> m;
long long low = 0LL;
long long high = 1000000000000000000LL;
long long ans = -1;
while (low <= high) {
long long mid = (low + high) / 2;
long long re = 0LL;
for (long long i = 2; i * i * i <= mid; i++) {
re += mid / (i * i * i);
}
if (re < m) {
low = mid + 1;
} else {
ans = mid;
high = mid - 1;
}
}
long long re = 0;
for (long long i = 2; i * i * i <= ans; i++) {
re += ans / (i * i * i);
}
if (re == m) {
cout << ans << endl;
} else {
cout << -1 << endl;
}
return 0;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
<image>
Input
The input contains a single integer a (0 ≤ a ≤ 15).
Output
Output a single integer.
Example
Input
3
Output
13
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int a, k1, k2, k3, k4;
int main() {
scanf("%d", &a);
k4 = a % 2;
a /= 2;
k3 = a % 2;
a /= 2;
k2 = a % 2;
a /= 2;
k1 = a;
k1 = 1 - k1;
if (k1) k2 = 1 - k2;
if (k1 && k2) k3 = 1 - k3;
if (k1 && k2 && k3) k4 = 1 - k4;
printf("%d\n", k4 + 2 * k3 + 4 * k2 + 8 * k1);
return 0;
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
For a positive integer n, we denote the integer obtained by reversing the decimal notation of n (without leading zeroes) by rev(n). For example, rev(123) = 321 and rev(4000) = 4.
You are given a positive integer D. How many positive integers N satisfy rev(N) = N + D?
Constraints
* D is an integer.
* 1 ≤ D < 10^9
Input
Input is given from Standard Input in the following format:
D
Output
Print the number of the positive integers N such that rev(N) = N + D.
Examples
Input
63
Output
2
Input
75
Output
0
Input
864197532
Output
1920
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using db = double;
#define pb push_back
ll d;
ll ans = 0;
ll p[19];
#define dig(x, i) ((x) / p[i] % 10)
map<int,int> pm, pf;
void dfs(ll s, int n, int i, ll mul) {
if (i * 2 + 1 == n) {
ans += !s * mul * 10;
return;
}
if (i < n / 2) {
ans += !s * mul;
return;
}
if (i < 19 && abs(s) > p[i + 1])
return;
for (auto j : (i == n - 1 ? pf : pm)) if (i <= 17 || j.first == 0)
dfs(s - j.first * (p[i] - p[n - 1 - i]), n, i - 1, mul * j.second);
}
int main() {
cin >> d;
for (int i = 0; i <= 9; ++i)
for (int j = 0; j <= 9; ++j) {
++pm[i - j];
if (i)
++pf[i - j];
}
p[0] = 1;
for (int i = 1; i < 19; ++i)
p[i] = p[i - 1] * 10;
for (int i = 2; i <= 24; ++i)
dfs(-d, i, i - 1, 1);
cout << ans << endl;
return 0;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
Eugene likes working with arrays. And today he needs your help in solving one challenging task.
An array c is a subarray of an array b if c can be obtained from b by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Let's call a nonempty array good if for every nonempty subarray of this array, sum of the elements of this subarray is nonzero. For example, array [-1, 2, -3] is good, as all arrays [-1], [-1, 2], [-1, 2, -3], [2], [2, -3], [-3] have nonzero sums of elements. However, array [-1, 2, -1, -3] isn't good, as his subarray [-1, 2, -1] has sum of elements equal to 0.
Help Eugene to calculate the number of nonempty good subarrays of a given array a.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 2 × 10^5) — the length of array a.
The second line of the input contains n integers a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9) — the elements of a.
Output
Output a single integer — the number of good subarrays of a.
Examples
Input
3
1 2 -3
Output
5
Input
3
41 -41 41
Output
3
Note
In the first sample, the following subarrays are good: [1], [1, 2], [2], [2, -3], [-3]. However, the subarray [1, 2, -3] isn't good, as its subarray [1, 2, -3] has sum of elements equal to 0.
In the second sample, three subarrays of size 1 are the only good subarrays. At the same time, the subarray [41, -41, 41] isn't good, as its subarray [41, -41] has sum of elements equal to 0.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int a[200009], b[200009], z[200009];
long long sum[200009];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), sum[i] = sum[i - 1] + a[i];
map<long long, int> mp;
long long ans = 0;
int l = 0;
mp[0] = 1;
for (int i = 1; i <= n; i++) {
while (mp[sum[i]]) mp[sum[l++]]--;
mp[sum[i]]++;
ans += (i - l);
}
printf("%lld\n", ans);
return 0;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
Being bored of exploring the Moon over and over again Wall-B decided to explore something he is made of — binary numbers. He took a binary number and decided to count how many times different substrings of length two appeared. He stored those values in c_{00}, c_{01}, c_{10} and c_{11}, representing how many times substrings 00, 01, 10 and 11 appear in the number respectively. For example:
10111100 → c_{00} = 1, \ c_{01} = 1,\ c_{10} = 2,\ c_{11} = 3
10000 → c_{00} = 3,\ c_{01} = 0,\ c_{10} = 1,\ c_{11} = 0
10101001 → c_{00} = 1,\ c_{01} = 3,\ c_{10} = 3,\ c_{11} = 0
1 → c_{00} = 0,\ c_{01} = 0,\ c_{10} = 0,\ c_{11} = 0
Wall-B noticed that there can be multiple binary numbers satisfying the same c_{00}, c_{01}, c_{10} and c_{11} constraints. Because of that he wanted to count how many binary numbers satisfy the constraints c_{xy} given the interval [A, B]. Unfortunately, his processing power wasn't strong enough to handle large intervals he was curious about. Can you help him? Since this number can be large print it modulo 10^9 + 7.
Input
First two lines contain two positive binary numbers A and B (1 ≤ A ≤ B < 2^{100 000}), representing the start and the end of the interval respectively. Binary numbers A and B have no leading zeroes.
Next four lines contain decimal numbers c_{00}, c_{01}, c_{10} and c_{11} (0 ≤ c_{00}, c_{01}, c_{10}, c_{11} ≤ 100 000) representing the count of two-digit substrings 00, 01, 10 and 11 respectively.
Output
Output one integer number representing how many binary numbers in the interval [A, B] satisfy the constraints mod 10^9 + 7.
Examples
Input
10
1001
0
0
1
1
Output
1
Input
10
10001
1
2
3
4
Output
0
Note
Example 1: The binary numbers in the interval [10,1001] are 10,11,100,101,110,111,1000,1001. Only number 110 satisfies the constraints: c_{00} = 0, c_{01} = 0, c_{10} = 1, c_{11} = 1.
Example 2: No number in the interval satisfies the constraints
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void maxtt(T& t1, T t2) {
t1 = max(t1, t2);
}
template <typename T>
void mintt(T& t1, T t2) {
t1 = min(t1, t2);
}
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
string direc = "RDLU";
long long ln, lk, lm;
void etp(bool f = 0) {
puts(f ? "YES" : "NO");
exit(0);
}
void addmod(int& x, int y, int mod = 1000000007) {
assert(y >= 0);
x += y;
if (x >= mod) x -= mod;
assert(x >= 0 && x < mod);
}
void et(int x = -1) {
printf("%d\n", x);
exit(0);
}
long long fastPow(long long x, long long y, int mod = 1000000007) {
long long ans = 1;
while (y > 0) {
if (y & 1) ans = (x * ans) % mod;
x = x * x % mod;
y >>= 1;
}
return ans;
}
long long gcd1(long long x, long long y) { return y ? gcd1(y, x % y) : x; }
char a[100035], b[100035];
int c[5];
int fac[100035], inv[100035];
void initfac(int n) {
fac[0] = inv[0] = 1;
for (int(i) = 1; (i) <= (int)(n); (i)++) {
fac[i] = (long long)fac[i - 1] * i % 1000000007;
inv[i] = fastPow(fac[i], 1000000007 - 2);
}
}
int C(int n, int m) {
if (n < m) return 0;
return (long long)fac[n] * inv[m] % 1000000007 * inv[n - m] % 1000000007;
}
int cal(int len, int st) {
int all = c[0] + c[1] + c[2] + c[3];
if (len - 1 != all) return 0;
if (abs(c[1] - c[2]) > 1) return 0;
int tmp = 0;
if (c[1] == c[2]) {
if (c[1] == 0) {
if (c[0] == 0 && st == 1) return 1;
if (c[3] == 0 && st == 0) return 1;
return 0;
}
int ones = c[2] + 1;
if (st == 1)
addmod(tmp, (long long)C(c[3] + ones - 1, ones - 1) *
C(c[0] + ones - 2, ones - 2) % 1000000007);
if (st == 0)
addmod(tmp, (long long)C(c[0] + ones - 1, ones - 1) *
C(c[3] + ones - 2, ones - 2) % 1000000007);
} else {
if (c[1] + 1 == c[2]) {
if (st != 1) return 0;
} else {
assert(c[2] + 1 == c[1]);
if (st != 0) return 0;
}
int ones = max(c[1], c[2]);
addmod(tmp, (long long)C(c[3] + ones - 1, ones - 1) *
C(c[0] + ones - 1, ones - 1) % 1000000007);
}
return tmp;
}
int N;
int dfs(char* s, int i, bool hd, int pre) {
if (i > N) return 0;
int len = N - i + 1;
int tmp = 0;
int num = s[i] - '0';
if (num == 1) {
if (hd) {
c[pre * 2 + 1]--;
addmod(tmp, dfs(s, i + 1, 1, 1));
c[pre * 2 + 1]++;
} else {
addmod(tmp, dfs(s, i + 1, 1, 1));
}
if (hd) {
c[pre * 2]--;
addmod(tmp, cal(len, 0));
c[pre * 2]++;
} else {
int all = c[0] + c[1] + c[2] + c[3];
if (all + 1 < len) addmod(tmp, cal(all + 1, 1));
}
} else {
if (hd) {
c[pre * 2]--;
addmod(tmp, dfs(s, i + 1, 1, 0));
c[pre * 2]++;
} else
addmod(tmp, dfs(s, i + 1, 0, 0));
}
return tmp;
}
void fmain(int tid) {
scanf("%s%s", a + 1, b + 1);
n = strlen(a + 1);
m = strlen(b + 1);
for (int(i) = 0; (i) < (int)(4); (i)++) scanf("%d", c + i);
initfac(m + 5);
N = n;
int A = dfs(a, 1, 0, 0);
int pos = m;
while (pos && b[pos] == '1') pos--;
if (pos == 0) {
b[0] = '0';
for (int(i) = 1; (i) <= (int)(m); (i)++) b[i + 1] = '1';
m++;
} else {
b[pos] = '1';
for (int i = pos + 1; i <= n; i++) b[i] = '0';
}
N = m;
int B = dfs(b, 1, 0, 0);
addmod(B, 1000000007 - A);
printf("%d\n", B);
}
int main() {
int t = 1;
for (int(i) = 1; (i) <= (int)(t); (i)++) {
fmain(i);
}
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
Maxim always goes to the supermarket on Sundays. Today the supermarket has a special offer of discount systems.
There are m types of discounts. We assume that the discounts are indexed from 1 to m. To use the discount number i, the customer takes a special basket, where he puts exactly qi items he buys. Under the terms of the discount system, in addition to the items in the cart the customer can receive at most two items from the supermarket for free. The number of the "free items" (0, 1 or 2) to give is selected by the customer. The only condition imposed on the selected "free items" is as follows: each of them mustn't be more expensive than the cheapest item out of the qi items in the cart.
Maxim now needs to buy n items in the shop. Count the minimum sum of money that Maxim needs to buy them, if he use the discount system optimally well.
Please assume that the supermarket has enough carts for any actions. Maxim can use the same discount multiple times. Of course, Maxim can buy items without any discounts.
Input
The first line contains integer m (1 ≤ m ≤ 105) — the number of discount types. The second line contains m integers: q1, q2, ..., qm (1 ≤ qi ≤ 105).
The third line contains integer n (1 ≤ n ≤ 105) — the number of items Maxim needs. The fourth line contains n integers: a1, a2, ..., an (1 ≤ ai ≤ 104) — the items' prices.
The numbers in the lines are separated by single spaces.
Output
In a single line print a single integer — the answer to the problem.
Examples
Input
1
2
4
50 50 100 100
Output
200
Input
2
2 3
5
50 50 50 50 50
Output
150
Input
1
1
7
1 1 1 1 1 1 1
Output
3
Note
In the first sample Maxim needs to buy two items that cost 100 and get a discount for two free items that cost 50. In that case, Maxim is going to pay 200.
In the second sample the best strategy for Maxim is to buy 3 items and get 2 items for free using the discount. In that case, Maxim is going to pay 150.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 5;
long long a[N];
long long b[N];
long long res = 0;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, m;
cin >> m;
long long c;
for (long long i = 1; i <= m; i++) {
cin >> b[i];
}
cin >> n;
for (long long i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
sort(b + 1, b + m + 1);
long long cnt = 0;
long long num = b[1];
for (long long i = n; i >= 1;) {
cnt++;
res += a[i];
if (cnt == num) {
cnt = 0;
i -= 2;
}
i--;
}
cout << res << endl;
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
You're given a tree with n vertices.
Your task is to determine the maximum possible number of edges that can be removed in such a way that all the remaining connected components will have even size.
Input
The first line contains an integer n (1 ≤ n ≤ 10^5) denoting the size of the tree.
The next n - 1 lines contain two integers u, v (1 ≤ u, v ≤ n) each, describing the vertices connected by the i-th edge.
It's guaranteed that the given edges form a tree.
Output
Output a single integer k — the maximum number of edges that can be removed to leave all connected components with even size, or -1 if it is impossible to remove edges in order to satisfy this property.
Examples
Input
4
2 4
4 1
3 1
Output
1
Input
3
1 2
1 3
Output
-1
Input
10
7 1
8 4
8 10
4 7
6 5
9 3
3 5
2 10
2 5
Output
4
Input
2
1 2
Output
0
Note
In the first example you can remove the edge between vertices 1 and 4. The graph after that will have two connected components with two vertices in each.
In the second example you can't remove edges in such a way that all components have even number of vertices, so the answer is -1.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
std::vector<int> g[100005];
int subt[100005];
bool vis[100005];
int n, cnt;
bool cmp(const pair<int, int> &a, const pair<int, int> &b) {
if (a.first == b.first) return a.second > b.second;
return a.first < b.first;
}
void dfs(int u, int p) {
subt[u] = 1;
vis[u] = 1;
for (auto v : g[u]) {
if (!vis[v]) {
dfs(v, u);
if (subt[v] % 2 == 0 && (n - subt[v]) % 2 == 0)
cnt++, n - subt[v];
else
subt[u] += subt[v];
}
}
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
dfs(1, 0);
if (n % 2 != 0 && cnt == 0) {
cout << -1;
return 0;
} else
cout << cnt;
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
Recently, Dima met with Sasha in a philatelic store, and since then they are collecting coins together. Their favorite occupation is to sort collections of coins. Sasha likes having things in order, that is why he wants his coins to be arranged in a row in such a way that firstly come coins out of circulation, and then come coins still in circulation.
For arranging coins Dima uses the following algorithm. One step of his algorithm looks like the following:
1. He looks through all the coins from left to right;
2. If he sees that the i-th coin is still in circulation, and (i + 1)-th coin is already out of circulation, he exchanges these two coins and continues watching coins from (i + 1)-th.
Dima repeats the procedure above until it happens that no two coins were exchanged during this procedure. Dima calls hardness of ordering the number of steps required for him according to the algorithm above to sort the sequence, e.g. the number of times he looks through the coins from the very beginning. For example, for the ordered sequence hardness of ordering equals one.
Today Sasha invited Dima and proposed him a game. First he puts n coins in a row, all of them are out of circulation. Then Sasha chooses one of the coins out of circulation and replaces it with a coin in circulation for n times. During this process Sasha constantly asks Dima what is the hardness of ordering of the sequence.
The task is more complicated because Dima should not touch the coins and he should determine hardness of ordering in his mind. Help Dima with this task.
Input
The first line contains single integer n (1 ≤ n ≤ 300 000) — number of coins that Sasha puts behind Dima.
Second line contains n distinct integers p1, p2, ..., pn (1 ≤ pi ≤ n) — positions that Sasha puts coins in circulation to. At first Sasha replaces coin located at position p1, then coin located at position p2 and so on. Coins are numbered from left to right.
Output
Print n + 1 numbers a0, a1, ..., an, where a0 is a hardness of ordering at the beginning, a1 is a hardness of ordering after the first replacement and so on.
Examples
Input
4
1 3 4 2
Output
1 2 3 2 1
Input
8
6 8 3 4 7 2 1 5
Output
1 2 2 3 4 3 4 5 1
Note
Let's denote as O coin out of circulation, and as X — coin is circulation.
At the first sample, initially in row there are coins that are not in circulation, so Dima will look through them from left to right and won't make any exchanges.
After replacement of the first coin with a coin in circulation, Dima will exchange this coin with next three times and after that he will finally look through the coins and finish the process.
XOOO → OOOX
After replacement of the third coin, Dima's actions look this way:
XOXO → OXOX → OOXX
After replacement of the fourth coin, Dima's actions look this way:
XOXX → OXXX
Finally, after replacement of the second coin, row becomes consisting of coins that are in circulation and Dima will look through coins from left to right without any exchanges.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, ar[300005], temp, right_id;
memset(ar, 0, sizeof(ar));
scanf("%d", &n);
right_id = n;
printf("1 ");
for (i = 1; i <= n; i++) {
scanf("%d", &temp);
ar[temp] = 1;
while (ar[right_id]) right_id--;
printf("%d ", i - n + right_id + 1);
}
return 0;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
You are given a bracket sequence s (not necessarily a regular one). A bracket sequence is a string containing only characters '(' and ')'.
A regular bracket sequence is a bracket sequence that can be transformed into a correct arithmetic expression by inserting characters '1' and '+' between the original characters of the sequence. For example, bracket sequences "()()" and "(())" are regular (the resulting expressions are: "(1)+(1)" and "((1+1)+1)"), and ")(", "(" and ")" are not.
Your problem is to calculate the number of regular bracket sequences of length 2n containing the given bracket sequence s as a substring (consecutive sequence of characters) modulo 10^9+7 (1000000007).
Input
The first line of the input contains one integer n (1 ≤ n ≤ 100) — the half-length of the resulting regular bracket sequences (the resulting sequences must have length equal to 2n).
The second line of the input contains one string s (1 ≤ |s| ≤ 200) — the string s that should be a substring in each of the resulting regular bracket sequences (|s| is the length of s).
Output
Print only one integer — the number of regular bracket sequences containing the given bracket sequence s as a substring. Since this number can be huge, print it modulo 10^9+7 (1000000007).
Examples
Input
5
()))()
Output
5
Input
3
(()
Output
4
Input
2
(((
Output
0
Note
All regular bracket sequences satisfying the conditions above for the first example:
* "(((()))())";
* "((()()))()";
* "((()))()()";
* "(()(()))()";
* "()((()))()".
All regular bracket sequences satisfying the conditions above for the second example:
* "((()))";
* "(()())";
* "(())()";
* "()(())".
And there is no regular bracket sequences of length 4 containing "(((" as a substring in the third example.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long M = 1e9 + 7;
long long DP[202][402][402];
string s;
int n;
long long POS[402];
long long solve(int pf, int pos, int deg) {
if (DP[pf][pos][deg] != -1) return DP[pf][pos][deg];
if (deg < 0) return 0;
if (pos >= 2 * n) return (pf >= s.size() && deg == 0 ? 1 : 0);
if (pf >= s.size()) {
return DP[pf][pos][deg] =
(solve(pf, pos + 1, deg + 1) + solve(pf, pos + 1, deg - 1)) % M;
} else {
long long ats = 0;
if (s[pf] == '(') {
ats = (ats + solve(pf + 1, pos + 1, deg + 1) +
solve(POS[pf], pos + 1, deg - 1)) %
M;
} else {
ats = (ats + solve(POS[pf], pos + 1, deg + 1) +
solve(pf + 1, pos + 1, deg - 1)) %
M;
}
return DP[pf][pos][deg] = ats;
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> s;
for (int i = 0; i < 202; i++)
for (int j = 0; j < 402; j++)
for (int k = 0; k < 402; k++) DP[i][j][k] = -1;
for (int i = 1; i < s.size(); i++) {
for (int j = 0; j <= i; j++) {
string z = s.substr(j, i - j) + (s[i] == '(' ? ")" : "(");
if (s.find(z) == 0) {
POS[i] = z.size();
break;
}
}
}
cout << solve(0, 0, 0);
}
``` |
### Prompt
Generate a cpp solution to the following problem:
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 <bits/stdc++.h>
using namespace std;
int n, l, t;
#define LL long long
const int N = 200000;
int xi[N], dir[N], xx[N];
int main()
{
// freopen("input.txt","r",stdin);
cin >> n >> l >> t;
LL c = 0;
for (int i = 0; i < n; ++ i)
{
cin >> xi[i] >> dir[i];
if (dir[i] == 2) dir[i] = -1;
int nx = xi[i] + t * dir[i];
c += (nx > 0? nx / l: (nx - l + 1) / l);
xx[i] = (nx % l + l) % l;
}
sort(xx, xx + n);
for (int i = 0; i < n; ++ i)
cout << xx[((i + c) % n + n) % n] << "\n";
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
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;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n, q, t;
cin >> n >> q >> t;
vector<long long> a(n + 1);
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
vector<int> nxt(n + 1, -1);
vector<int> source(n + 1, 1);
for (int i = 0; i < q; i++) {
int u, v;
cin >> u >> v;
source[u] = 0;
nxt[v] = u;
}
vector<long long> cost(n + 1, 0);
vector<int> vis(n + 1, 0);
for (int u = 1; u <= n; u++) {
if (source[u] == 0) continue;
vector<int> dag;
int cur = u;
while (cur != -1) {
vis[cur] = 1;
dag.push_back(cur);
cur = nxt[cur];
}
long long sum = 0;
for (int j = int(dag.size()) - 1; j >= 0; j--) {
sum += a[dag[j]];
cost[dag[j]] = sum;
if (j != 0) t -= sum;
}
}
if (t < 0 or accumulate(begin(vis), end(vis), 0) != n) {
cout << 0 << '\n';
return (0);
}
vector<int> dp(t + 1, 0);
const int mod = 1e9 + 7;
dp[0] = 1;
for (int u = 1; u <= n; u++) {
long long add = cost[u];
for (long long z = 0; z + add <= t; z++) {
dp[z + add] += dp[z];
if (dp[z + add] >= mod) dp[z + add] -= mod;
}
}
cout << dp[t] << '\n';
return (0);
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Mad scientist Mike is building a time machine in his spare time. To finish the work, he needs a resistor with a certain resistance value.
However, all Mike has is lots of identical resistors with unit resistance R0 = 1. Elements with other resistance can be constructed from these resistors. In this problem, we will consider the following as elements:
1. one resistor;
2. an element and one resistor plugged in sequence;
3. an element and one resistor plugged in parallel.
<image>
With the consecutive connection the resistance of the new element equals R = Re + R0. With the parallel connection the resistance of the new element equals <image>. In this case Re equals the resistance of the element being connected.
Mike needs to assemble an element with a resistance equal to the fraction <image>. Determine the smallest possible number of resistors he needs to make such an element.
Input
The single input line contains two space-separated integers a and b (1 ≤ a, b ≤ 1018). It is guaranteed that the fraction <image> is irreducible. It is guaranteed that a solution always exists.
Output
Print a single number — the answer to the problem.
Please do not use the %lld specifier to read or write 64-bit integers in С++. It is recommended to use the cin, cout streams or the %I64d specifier.
Examples
Input
1 1
Output
1
Input
3 2
Output
3
Input
199 200
Output
200
Note
In the first sample, one resistor is enough.
In the second sample one can connect the resistors in parallel, take the resulting element and connect it to a third resistor consecutively. Then, we get an element with resistance <image>. We cannot make this element using two resistors.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int a, b;
cin >> a >> b;
long long int ans = 0;
while (true) {
if (a == 1 || b == 1) {
cout << ans + max(a, b);
return 0;
}
if (a > b) {
ans += (a / b);
a = a - ((a / b) * b);
}
if (a == 1) {
cout << ans + b;
return 0;
}
if (b > a) {
ans += (b / a);
b = b - ((b / a) * a);
}
if (b == 1) {
cout << ans + a;
return 0;
}
}
return 0;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
There are n water tanks in a row, i-th of them contains a_i liters of water. The tanks are numbered from 1 to n from left to right.
You can perform the following operation: choose some subsegment [l, r] (1≤ l ≤ r ≤ n), and redistribute water in tanks l, l+1, ..., r evenly. In other words, replace each of a_l, a_{l+1}, ..., a_r by \frac{a_l + a_{l+1} + ... + a_r}{r-l+1}. For example, if for volumes [1, 3, 6, 7] you choose l = 2, r = 3, new volumes of water will be [1, 4.5, 4.5, 7]. You can perform this operation any number of times.
What is the lexicographically smallest sequence of volumes of water that you can achieve?
As a reminder:
A sequence a is lexicographically smaller than a sequence b of the same length if and only if the following holds: in the first (leftmost) position where a and b differ, the sequence a has a smaller element than the corresponding element in b.
Input
The first line contains an integer n (1 ≤ n ≤ 10^6) — the number of water tanks.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^6) — initial volumes of water in the water tanks, in liters.
Because of large input, reading input as doubles is not recommended.
Output
Print the lexicographically smallest sequence you can get. In the i-th line print the final volume of water in the i-th tank.
Your answer is considered correct if the absolute or relative error of each a_i does not exceed 10^{-9}.
Formally, let your answer be a_1, a_2, ..., a_n, and the jury's answer be b_1, b_2, ..., b_n. Your answer is accepted if and only if \frac{|a_i - b_i|}{max{(1, |b_i|)}} ≤ 10^{-9} for each i.
Examples
Input
4
7 5 5 7
Output
5.666666667
5.666666667
5.666666667
7.000000000
Input
5
7 8 8 10 12
Output
7.000000000
8.000000000
8.000000000
10.000000000
12.000000000
Input
10
3 9 5 5 1 7 5 3 8 7
Output
3.000000000
5.000000000
5.000000000
5.000000000
5.000000000
5.000000000
5.000000000
5.000000000
7.500000000
7.500000000
Note
In the first sample, you can get the sequence by applying the operation for subsegment [1, 3].
In the second sample, you can't get any lexicographically smaller sequence.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <typename elemType>
inline void Read(elemType &T) {
elemType X = 0, w = 0;
char ch = 0;
while (!isdigit(ch)) {
w |= ch == '-';
ch = getchar();
}
while (isdigit(ch)) X = (X << 3) + (X << 1) + (ch ^ 48), ch = getchar();
T = (w ? -X : X);
}
struct Node {
long long Len, Sum;
double Ave;
};
stack<Node> S;
vector<double> Ans;
int N;
inline void Push(long long x) {
Node Cur;
Cur.Sum = x;
Cur.Len = 1;
Cur.Ave = x;
while (!S.empty()) {
double CurAve =
(double)(S.top().Sum + Cur.Sum) / (double)(S.top().Len + Cur.Len);
if (CurAve > S.top().Ave) break;
Cur.Sum += S.top().Sum;
Cur.Len += S.top().Len;
Cur.Ave = CurAve;
S.pop();
}
S.push(Cur);
}
int main() {
Read(N);
for (register int i = 1; i <= N; ++i) {
long long x;
Read(x);
Push(x);
}
while (!S.empty()) {
for (register int i = 1; i <= S.top().Len; ++i) Ans.push_back(S.top().Ave);
S.pop();
}
for (register int i = Ans.size() - 1; i >= 0; --i) printf("%.9f\n", Ans[i]);
return 0;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
Bearland is a dangerous place. Limak can’t travel on foot. Instead, he has k magic teleportation stones. Each stone can be used at most once. The i-th stone allows to teleport to a point (axi, ayi). Limak can use stones in any order.
There are n monsters in Bearland. The i-th of them stands at (mxi, myi).
The given k + n points are pairwise distinct.
After each teleportation, Limak can shoot an arrow in some direction. An arrow will hit the first monster in the chosen direction. Then, both an arrow and a monster disappear. It’s dangerous to stay in one place for long, so Limak can shoot only one arrow from one place.
A monster should be afraid if it’s possible that Limak will hit it. How many monsters should be afraid of Limak?
Input
The first line of the input contains two integers k and n (1 ≤ k ≤ 7, 1 ≤ n ≤ 1000) — the number of stones and the number of monsters.
The i-th of following k lines contains two integers axi and ayi ( - 109 ≤ axi, ayi ≤ 109) — coordinates to which Limak can teleport using the i-th stone.
The i-th of last n lines contains two integers mxi and myi ( - 109 ≤ mxi, myi ≤ 109) — coordinates of the i-th monster.
The given k + n points are pairwise distinct.
Output
Print the number of monsters which should be afraid of Limak.
Examples
Input
2 4
-2 -1
4 5
4 2
2 1
4 -1
1 -1
Output
3
Input
3 8
10 20
0 0
20 40
300 600
30 60
170 340
50 100
28 56
90 180
-4 -8
-1 -2
Output
5
Note
In the first sample, there are two stones and four monsters. Stones allow to teleport to points ( - 2, - 1) and (4, 5), marked blue in the drawing below. Monsters are at (4, 2), (2, 1), (4, - 1) and (1, - 1), marked red. A monster at (4, - 1) shouldn't be afraid because it's impossible that Limak will hit it with an arrow. Other three monsters can be hit and thus the answer is 3.
<image>
In the second sample, five monsters should be afraid. Safe monsters are those at (300, 600), (170, 340) and (90, 180).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
pair<int, int> a[10], b[1010];
vector<int> e[10][1010], tmp;
int k, n, p[10], pos;
bool vis[1010], ok[1010];
bool check(pair<int, int> x, pair<int, int> y, pair<int, int> z) {
if (x.first < min(y.first, z.first) || x.first > max(y.first, z.first))
return false;
if (x.second < min(y.second, z.second) || x.second > max(y.second, z.second))
return false;
return 1ll * (y.second - x.second) * (z.first - x.first) ==
1ll * (z.second - x.second) * (y.first - x.first);
}
bool dfs(int x) {
if (pos > k) return false;
for (int y : e[p[pos]][x]) {
if (!vis[y]) {
++pos;
if (!dfs(y)) return false;
}
}
tmp.push_back(x), vis[x] = true;
return true;
}
int main() {
scanf("%d%d", &k, &n);
for (int i = 1; i <= k; i++) scanf("%d%d", &a[i].first, &a[i].second);
for (int i = 1; i <= n; i++) scanf("%d%d", &b[i].first, &b[i].second);
for (int i = 1; i <= k; i++)
for (int j = 1; j <= n; j++) {
for (int l = 1; l <= n; l++) {
if (j == l) continue;
if (check(b[l], a[i], b[j])) e[i][j].push_back(l);
if ((int)e[i][j].size() == k) break;
}
}
int res = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= k; j++) p[j] = j;
do {
while (!tmp.empty()) vis[tmp.back()] = 0, tmp.pop_back();
pos = 1;
if (dfs(i)) {
res++;
break;
}
} while (next_permutation(p + 1, p + k + 1));
}
printf("%d\n", res);
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
You want to go on a trip with a friend. However, friends who have a habit of spending money cannot easily save travel expenses. I don't know when my friends will go on a trip if they continue their current lives. So, if you want to travel early, you decide to create a program to help your friends save in a planned manner.
If you have a friend's pocket money of M yen and the money you spend in that month is N yen, you will save (M --N) yen in that month. Create a program that inputs the monthly income and expenditure information M and N and outputs the number of months it takes for the savings amount to reach the travel cost L. However, if your savings do not reach your travel expenses after 12 months, print NA.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
L
M1 N1
M2 N2
::
M12 N12
The first line gives the travel cost L (1 ≤ L ≤ 1000000, integer). The next 12 lines are given the balance information for the i month, Mi, Ni (0 ≤ Mi, Ni ≤ 100000, Ni ≤ Mi, integer).
The number of datasets does not exceed 1000.
Output
For each input dataset, print the number of months it takes for your savings to reach your travel costs on a single line.
Example
Input
10000
5000 3150
5000 5000
0 0
5000 1050
5000 3980
5000 210
5000 5000
5000 5000
0 0
5000 2100
5000 2100
5000 2100
29170
100000 100000
100000 100000
100000 100000
100000 100000
100000 100000
100000 100000
100000 100000
100000 100000
100000 100000
100000 100000
100000 100000
100000 70831
0
Output
6
NA
### Response
```cpp
#include <stdio.h>
int l, m, n;
int main() {
while (true) {
scanf("%d", &l);
if (l == 0) break;
bool flag = false;
for (int i = 0; i < 12; i++) {
scanf("%d%d", &m, &n);
l -= (m - n);
if (l <= 0 && !flag) {
printf("%d\n", i + 1); flag = true;
}
}
if (!flag) printf("NA\n");
}
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
All Berland residents are waiting for an unprecedented tour of wizard in his Blue Helicopter over the cities of Berland!
It is well-known that there are n cities in Berland, some pairs of which are connected by bidirectional roads. Each pair of cities is connected by no more than one road. It is not guaranteed that the road network is connected, i.e. it is possible that you can't reach some city from some other.
The tour will contain several episodes. In each of the episodes:
* the wizard will disembark at some city x from the Helicopter;
* he will give a performance and show a movie for free at the city x;
* he will drive to some neighboring city y using a road;
* he will give a performance and show a movie for free at the city y;
* he will drive to some neighboring to y city z;
* he will give a performance and show a movie for free at the city z;
* he will embark the Helicopter and fly away from the city z.
It is known that the wizard doesn't like to use roads, so he agrees to use each road at most once (regardless of direction). In other words, for road between a and b he only can drive once from a to b, or drive once from b to a, or do not use this road at all.
The wizards wants to plan as many episodes as possible without violation the above rules. Help the wizard!
Please note that the wizard can visit the same city multiple times, the restriction is on roads only.
Input
The first line contains two integers n, m (1 ≤ n ≤ 2·105, 0 ≤ m ≤ 2·105) — the number of cities and the number of roads in Berland, respectively.
The roads description follow, one in each line. Each description is a pair of two integers ai, bi (1 ≤ ai, bi ≤ n, ai ≠ bi), where ai and bi are the ids of the cities connected by the i-th road. It is guaranteed that there are no two roads connecting the same pair of cities. Every road is bidirectional. The cities are numbered from 1 to n.
It is possible that the road network in Berland is not connected.
Output
In the first line print w — the maximum possible number of episodes. The next w lines should contain the episodes in format x, y, z — the three integers denoting the ids of the cities in the order of the wizard's visits.
Examples
Input
4 5
1 2
3 2
2 4
3 4
4 1
Output
2
1 4 2
4 3 2
Input
5 8
5 3
1 2
4 5
5 1
2 5
4 3
1 4
3 2
Output
4
1 4 5
2 3 4
1 5 3
5 2 1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int mxN = 2e5 + 5;
struct itsuki {
int a, b, c;
};
int n, m;
vector<int> adj[mxN];
vector<itsuki> ans;
bool vis[mxN];
bool dfs(int u, int p) {
vis[u] = 1;
vector<int> miku;
for (int &v : adj[u]) {
if (v == p) continue;
if (vis[v]) {
if (u < v) miku.push_back(v);
} else {
if (dfs(v, u)) miku.push_back(v);
}
}
for (int i = 0; i < miku.size() / 2; i++) {
ans.push_back({miku[i * 2], u, miku[i * 2 + 1]});
}
if (miku.size() % 2 == 0) return 1;
if (p != -1) {
ans.push_back({p, u, miku[miku.size() - 1]});
}
return 0;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = 1; i <= n; i++)
if (!vis[i]) dfs(i, -1);
cout << ans.size() << '\n';
for (int i = 0; i < ans.size(); i++) {
cout << ans[i].a << ' ' << ans[i].b << ' ' << ans[i].c << '\n';
}
}
``` |
### Prompt
Your challenge is to write 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;
void err(istringstream *iss) {}
template <typename T, typename... Args>
void err(istringstream *iss, const T &varVal, const Args &...args) {
string varName;
*iss >> varName;
if (varName.back() == ',') varName.back() = ' ';
cout << varName << " = " << varVal << "; ", err(iss, args...);
}
int n, m, K, T, Q, cn;
int lcm[] = {0, 1, 2, 6, 12, 60, 60, 420,
840, 2520, 2520, 27720, 27720, 360360, 360360, 360360};
long long a, b;
long long func(long long hi, long long lo) {
long long ret = 0;
while (hi > lo) {
long long mx = 1;
for (int i = 2; i <= K; i++) {
if (hi % i <= hi - lo) mx = max(mx, hi % i);
}
hi -= mx;
ret++;
}
return ret;
}
int main() {
cin.tie(NULL);
scanf("%lld%lld%d", &a, &b, &K);
int l = lcm[K];
long long x = ((b - 1) / l + 1) * l, y = a / l * l;
printf("%lld\n", a - b <= l ? func(a, b)
: func(x, b) + (y / l - x / l) * func(x + l, x) +
func(a, y));
return 0;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
Allen is hosting a formal dinner party. 2n people come to the event in n pairs (couples). After a night of fun, Allen wants to line everyone up for a final picture. The 2n people line up, but Allen doesn't like the ordering. Allen prefers if each pair occupies adjacent positions in the line, as this makes the picture more aesthetic.
Help Allen find the minimum number of swaps of adjacent positions he must perform to make it so that each couple occupies adjacent positions in the line.
Input
The first line contains a single integer n (1 ≤ n ≤ 100), the number of pairs of people.
The second line contains 2n integers a_1, a_2, ..., a_{2n}. For each i with 1 ≤ i ≤ n, i appears exactly twice. If a_j = a_k = i, that means that the j-th and k-th people in the line form a couple.
Output
Output a single integer, representing the minimum number of adjacent swaps needed to line the people up so that each pair occupies adjacent positions.
Examples
Input
4
1 1 2 3 3 2 4 4
Output
2
Input
3
1 1 2 2 3 3
Output
0
Input
3
3 1 2 3 1 2
Output
3
Note
In the first sample case, we can transform 1 1 2 3 3 2 4 4 → 1 1 2 3 2 3 4 4 → 1 1 2 2 3 3 4 4 in two steps. Note that the sequence 1 1 2 3 3 2 4 4 → 1 1 3 2 3 2 4 4 → 1 1 3 3 2 2 4 4 also works in the same number of steps.
The second sample case already satisfies the constraints; therefore we need 0 swaps.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 5;
const int32_t M = 998244353;
void solve() {
long long n;
cin >> n;
vector<long long> a(2 * n);
for (long long i = 0; i < (long long)2 * n; ++i) cin >> a[i];
vector<long long> vis(2 * n);
long long ans = 0;
for (long long i = 0; i < (long long)2 * n; ++i) {
if (!vis[a[i]]) {
long long cnt = 0;
for (long long j = i + 1; j < 2 * n; j++) {
if (a[j] == a[i]) break;
if (!vis[a[j]]) cnt++;
}
vis[a[i]] = 1;
ans += cnt;
}
}
cout << ans << "\n";
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
long long a = 1;
while (t--) {
solve();
a += 1;
}
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
There are two small spaceship, surrounded by two groups of enemy larger spaceships. The space is a two-dimensional plane, and one group of the enemy spaceships is positioned in such a way that they all have integer y-coordinates, and their x-coordinate is equal to -100, while the second group is positioned in such a way that they all have integer y-coordinates, and their x-coordinate is equal to 100.
Each spaceship in both groups will simultaneously shoot two laser shots (infinite ray that destroys any spaceship it touches), one towards each of the small spaceships, all at the same time. The small spaceships will be able to avoid all the laser shots, and now want to position themselves at some locations with x=0 (with not necessarily integer y-coordinates), such that the rays shot at them would destroy as many of the enemy spaceships as possible. Find the largest numbers of spaceships that can be destroyed this way, assuming that the enemy spaceships can't avoid laser shots.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 60), the number of enemy spaceships with x = -100 and the number of enemy spaceships with x = 100, respectively.
The second line contains n integers y_{1,1}, y_{1,2}, …, y_{1,n} (|y_{1,i}| ≤ 10 000) — the y-coordinates of the spaceships in the first group.
The third line contains m integers y_{2,1}, y_{2,2}, …, y_{2,m} (|y_{2,i}| ≤ 10 000) — the y-coordinates of the spaceships in the second group.
The y coordinates are not guaranteed to be unique, even within a group.
Output
Print a single integer – the largest number of enemy spaceships that can be destroyed.
Examples
Input
3 9
1 2 3
1 2 3 7 8 9 11 12 13
Output
9
Input
5 5
1 2 3 4 5
1 2 3 4 5
Output
10
Note
In the first example the first spaceship can be positioned at (0, 2), and the second – at (0, 7). This way all the enemy spaceships in the first group and 6 out of 9 spaceships in the second group will be destroyed.
In the second example the first spaceship can be positioned at (0, 3), and the second can be positioned anywhere, it will be sufficient to destroy all the enemy spaceships.
### Response
```cpp
#include <bits/stdc++.h>
#pragma GCC optimize(3)
using namespace std;
const double PI = acos(-1.0);
const double eps = 1e-6;
const int INF = 0x3f3f3f3f;
const int maxn = 40000 + 11;
int N, M, T, a[maxn], b[maxn], ca[maxn], cb[maxn];
bitset<62> vis1, vis2, mska[maxn], mskb[maxn];
vector<int> v;
int main() {
cin >> N >> M;
for (int i = 1; i <= N; i++) scanf("%d", &a[i]);
for (int i = 1; i <= N; i++) a[i] = 2 * (a[i] + 10000);
for (int i = 1; i <= M; i++) scanf("%d", &b[i]);
for (int i = 1; i <= M; i++) b[i] = 2 * (b[i] + 10000);
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= M; j++) {
mska[(a[i] + b[j]) / 2][i] = 1;
mskb[(a[i] + b[j]) / 2][j] = 1;
v.push_back((a[i] + b[j]) / 2);
}
}
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
T = v.size();
int ans = 0;
for (int i = 0; i < T; i++) {
for (int j = i; j < T; j++) {
ans = max(ans, int((mska[v[i]] | mska[v[j]]).count() +
(mskb[v[i]] | mskb[v[j]]).count()));
}
}
cout << ans << endl;
return 0;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
Berland scientists face a very important task - given the parts of short DNA fragments, restore the dinosaur DNA! The genome of a berland dinosaur has noting in common with the genome that we've used to: it can have 26 distinct nucleotide types, a nucleotide of each type can occur at most once. If we assign distinct English letters to all nucleotides, then the genome of a Berland dinosaur will represent a non-empty string consisting of small English letters, such that each letter occurs in it at most once.
Scientists have n genome fragments that are represented as substrings (non-empty sequences of consecutive nucleotides) of the sought genome.
You face the following problem: help scientists restore the dinosaur genome. It is guaranteed that the input is not contradictory and at least one suitable line always exists. When the scientists found out that you are a strong programmer, they asked you in addition to choose the one with the minimum length. If there are multiple such strings, choose any string.
Input
The first line of the input contains a positive integer n (1 ≤ n ≤ 100) — the number of genome fragments.
Each of the next lines contains one descriptions of a fragment. Each fragment is a non-empty string consisting of distinct small letters of the English alphabet. It is not guaranteed that the given fragments are distinct. Fragments could arbitrarily overlap and one fragment could be a substring of another one.
It is guaranteed that there is such string of distinct letters that contains all the given fragments as substrings.
Output
In the single line of the output print the genome of the minimum length that contains all the given parts. All the nucleotides in the genome must be distinct. If there are multiple suitable strings, print the string of the minimum length. If there also are multiple suitable strings, you can print any of them.
Examples
Input
3
bcd
ab
cdef
Output
abcdef
Input
4
x
y
z
w
Output
xyzw
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct slovo {
char sl[30];
int dlina;
};
int tabl[26][3];
int main() {
std::ios::sync_with_stdio(false);
slovo mas[105];
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> mas[i].sl;
mas[i].dlina = strlen(mas[i].sl);
}
for (int i = 0; i < 26; i++) {
tabl[i][0] = -1;
tabl[i][2] = -1;
tabl[i][1] = 0;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < mas[i].dlina - 1; j++) {
tabl[int(mas[i].sl[j]) - 97][1] = int(mas[i].sl[j]);
tabl[int(mas[i].sl[j]) - 97][2] = int(mas[i].sl[j + 1]) - 97;
tabl[int(mas[i].sl[j + 1]) - 97][1] = int(mas[i].sl[j + 1]);
tabl[int(mas[i].sl[j + 1]) - 97][0] = int(mas[i].sl[j] - 97);
}
if (mas[i].dlina == 1) {
tabl[int(mas[i].sl[0]) - 97][1] = int(mas[i].sl[0]);
} else if (mas[i].dlina > 1) {
tabl[int(mas[i].sl[mas[i].dlina - 1]) - 97][0] =
int(mas[i].sl[mas[i].dlina - 2]) - 97;
}
}
int ful = 0;
for (int i = 0; i < 26; i++)
if (tabl[i][1] != 0) ful++;
int ful2 = 0;
for (int i = 0; i < 26; i++)
if (tabl[i][1] != 0 && tabl[i][0] != -1 && tabl[i][1] != -1) ful2++;
if (ful == ful2) {
int st = -1;
for (int i = 0; i < 26; i++)
if (tabl[i][0] != -1 && tabl[i][2] != -1) {
st = i;
break;
}
if (st != -1) {
int i = st;
while (tabl[i][2] != -1) {
if (tabl[i][1] >= 97) cout << char(tabl[i][1]);
st = tabl[i][2];
tabl[i][0] = -1;
tabl[i][1] = 0;
tabl[i][2] = -1;
i = st;
}
}
}
int fl = 1;
while (fl != 2) {
int st = -1;
for (int i = 0; i < 26; i++)
if (tabl[i][0] == -1 && tabl[i][2] != -1) {
st = i;
break;
}
if (st == -1) fl = 2;
if (st != -1) {
int i = st;
int vivod_posl = -1;
while (tabl[i][2] != -1) {
cout << char(tabl[i][1]);
st = tabl[i][2];
tabl[i][0] = -1;
tabl[i][1] = 0;
tabl[i][2] = -1;
i = st;
vivod_posl = 1;
}
if (vivod_posl == 1) {
cout << char(tabl[i][1]);
tabl[i][0] = -1;
tabl[i][1] = 0;
tabl[i][2] = -1;
}
}
}
for (int i = 0; i < 26; i++)
if (tabl[i][1] != 0) {
cout << char(tabl[i][1]);
tabl[i][0] = -1;
tabl[i][1] = 0;
tabl[i][2] = -1;
}
return 0;
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
Problem statement
Meatishi can increase or decrease the number of fingers.
There are n buns in front of Nikunishi-kun.
Meatishi is trying to count the number of steamed buns by breaking his finger.
There are only two shapes that Nishikun's fingers can take, whether they are broken or not.
Nikunishi understands binary numbers.
Nikunishi-kun can count numbers by associating each finger with a binary digit.
Nikunishi doesn't understand the logarithm.
Find the minimum number of fingers needed to count the buns instead of Nishikun.
input
n
Constraint
* An integer
* 0 ≤ n ≤ 1018
output
Print the answer on one line, and print a newline at the end.
sample
Sample input 1
0
Sample output 1
0
Sample input 2
Four
Sample output 2
3
Sample input 3
31
Sample output 3
Five
Sample input 4
36028797018963968
Sample output 4
56
Example
Input
0
Output
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef complex<double> P;
#define REP(i,n) for(int i=0;i<n;++i)
#define REPR(i,n) for(int i=1;i<n;++i)
#define DEBUG(x) cout<<#x<<": "<<x<<endl
#define DEBUG_VEC(v) REP(i,v.size())cout<<#v<<"["<<i<<"]: "<<v[i]<<endl
#define ALL(a) (a).begin(),(a).end()
int main(){
ll n;
cin >> n;
int result = 0;
while(n){
n/=2;
++result;
}
cout << result << endl;
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
Bob watches TV every day. He always sets the volume of his TV to b. However, today he is angry to find out someone has changed the volume to a. Of course, Bob has a remote control that can change the volume.
There are six buttons (-5, -2, -1, +1, +2, +5) on the control, which in one press can either increase or decrease the current volume by 1, 2, or 5. The volume can be arbitrarily large, but can never be negative. In other words, Bob cannot press the button if it causes the volume to be lower than 0.
As Bob is so angry, he wants to change the volume to b using as few button presses as possible. However, he forgets how to do such simple calculations, so he asks you for help. Write a program that given a and b, finds the minimum number of presses to change the TV volume from a to b.
Input
Each test contains multiple test cases. The first line contains the number of test cases T (1 ≤ T ≤ 1 000). Then the descriptions of the test cases follow.
Each test case consists of one line containing two integers a and b (0 ≤ a, b ≤ 10^{9}) — the current volume and Bob's desired volume, respectively.
Output
For each test case, output a single integer — the minimum number of presses to change the TV volume from a to b. If Bob does not need to change the volume (i.e. a=b), then print 0.
Example
Input
3
4 0
5 14
3 9
Output
2
3
2
Note
In the first example, Bob can press the -2 button twice to reach 0. Note that Bob can not press -5 when the volume is 4 since it will make the volume negative.
In the second example, one of the optimal ways for Bob is to press the +5 twice, then press -1 once.
In the last example, Bob can press the +5 once, then press +1.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
long long pos_a = 1, pos_b = 7;
cin >> t;
while (t--) {
long long a, b;
long long cnt = 0;
long long x;
cin >> a >> b;
if (a == b)
cout << "0" << endl;
else {
cnt = abs(a - b) / 5;
x = abs(a - b) % 5;
if (x == 0)
cout << cnt << endl;
else if (x == 1 || x == 2)
cout << cnt + 1 << endl;
else if (x == 3 || x == 4)
cout << cnt + 2 << endl;
}
}
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
There are n Christmas trees on an infinite number line. The i-th tree grows at the position x_i. All x_i are guaranteed to be distinct.
Each integer point can be either occupied by the Christmas tree, by the human or not occupied at all. Non-integer points cannot be occupied by anything.
There are m people who want to celebrate Christmas. Let y_1, y_2, ..., y_m be the positions of people (note that all values x_1, x_2, ..., x_n, y_1, y_2, ..., y_m should be distinct and all y_j should be integer). You want to find such an arrangement of people that the value ∑_{j=1}^{m}min_{i=1}^{n}|x_i - y_j| is the minimum possible (in other words, the sum of distances to the nearest Christmas tree for all people should be minimized).
In other words, let d_j be the distance from the j-th human to the nearest Christmas tree (d_j = min_{i=1}^{n} |y_j - x_i|). Then you need to choose such positions y_1, y_2, ..., y_m that ∑_{j=1}^{m} d_j is the minimum possible.
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 2 ⋅ 10^5) — the number of Christmas trees and the number of people.
The second line of the input contains n integers x_1, x_2, ..., x_n (-10^9 ≤ x_i ≤ 10^9), where x_i is the position of the i-th Christmas tree. It is guaranteed that all x_i are distinct.
Output
In the first line print one integer res — the minimum possible value of ∑_{j=1}^{m}min_{i=1}^{n}|x_i - y_j| (in other words, the sum of distances to the nearest Christmas tree for all people).
In the second line print m integers y_1, y_2, ..., y_m (-2 ⋅ 10^9 ≤ y_j ≤ 2 ⋅ 10^9), where y_j is the position of the j-th human. All y_j should be distinct and all values x_1, x_2, ..., x_n, y_1, y_2, ..., y_m should be distinct.
If there are multiple answers, print any of them.
Examples
Input
2 6
1 5
Output
8
-1 2 6 4 0 3
Input
3 5
0 3 1
Output
7
5 -2 4 -1 2
### Response
```cpp
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
using namespace std;
void solve() {
int n, m;
cin >> n >> m;
vector<int> t(n);
map<int, bool> vis;
vector<int> ans;
long long sum = 0;
for (int i = 0; i < n; i++) {
cin >> t[i];
vis[t[i]] = 1;
}
priority_queue<pair<int, int>, vector<pair<int, int>>,
greater<pair<int, int>>>
q;
for (int i = 0; i < n; i++) {
q.push({1, t[i] + 1}), q.push({1, t[i] - 1});
}
sort(t.begin(), t.end());
while (m) {
auto x = q.top();
q.pop();
if (vis[x.second]) continue;
m--;
vis[x.second] = 1;
sum += x.first;
ans.push_back(x.second);
int cur = x.second;
for (auto nx : {cur - 1, cur + 1}) {
if (vis[nx]) continue;
auto it = lower_bound(t.begin(), t.end(), nx);
int mn = 2e9 + 1;
if (it == t.end()) {
mn = min(mn, nx - t.back());
} else {
mn = min(mn, abs(nx - *it));
if (it != t.begin()) {
it--;
mn = min(mn, abs(nx - *it));
}
}
q.push({mn, nx});
}
}
cout << sum << "\n";
for (auto x : ans) cout << x << " ";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
solve();
cout << "\n";
}
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
Today is Matvey's birthday. He never knows what to ask as a present so friends gave him a string s of length n. This string consists of only first eight English letters: 'a', 'b', ..., 'h'.
First question that comes to mind is: who might ever need some string? Matvey is a special boy so he instantly found what to do with this string. He used it to build an undirected graph where vertices correspond to position in the string and there is an edge between distinct positions a and b (1 ≤ a, b ≤ n) if at least one of the following conditions hold:
1. a and b are neighbouring, i.e. |a - b| = 1.
2. Positions a and b contain equal characters, i.e. sa = sb.
Then Matvey decided to find the diameter of this graph. Diameter is a maximum distance (length of the shortest path) among all pairs of vertices. Also, Matvey wants to find the number of pairs of vertices such that the distance between them is equal to the diameter of the graph. As he is very cool and experienced programmer he managed to solve this problem very fast. Will you do the same?
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 100 000) — the length of the string.
The second line contains the string s itself. It's guaranteed that s consists of only first eight letters of English alphabet.
Output
Print two integers — the diameter of the graph and the number of pairs of positions with the distance equal to the diameter.
Examples
Input
3
abc
Output
2 1
Input
7
aaabaaa
Output
2 4
Note
Consider the second sample.
The maximum distance is 2. It's obtained for pairs (1, 4), (2, 4), (4, 6) and (4, 7).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int sp = (2 * 8 - 1);
const int lim = (1 << 8);
int n, i, j;
char s[100011];
vector<int> wh_col[8];
bool color_used[8];
queue<int> Q;
int dist[100011][8];
int dist_col[8][8];
int mask[100011];
int enabled[8][1 << 8];
int l, r;
long long best, cnt;
void compute_dist(int col) {
int i;
memset(color_used, 0, sizeof(color_used));
while (!Q.empty()) Q.pop();
for (i = 1; i <= n; i++) dist[i][col] = 10000000;
for (auto e : wh_col[col]) dist[e][col] = 0, Q.push(e);
while (!Q.empty()) {
int node = Q.front();
Q.pop();
if (dist[node - 1][col] > dist[node][col] + 1) {
dist[node - 1][col] = dist[node][col] + 1;
Q.push(node - 1);
}
if (dist[node + 1][col] > dist[node][col] + 1) {
dist[node + 1][col] = dist[node][col] + 1;
Q.push(node + 1);
}
if (!color_used[s[node] - 'a']) {
color_used[s[node] - 'a'] = true;
for (auto e : wh_col[s[node] - 'a']) {
if (dist[e][col] > dist[node][col] + 1) {
dist[e][col] = dist[node][col] + 1;
Q.push(e);
}
}
}
}
}
void compute_dist_col() {
int i, j, k;
for (i = 0; i < 8; i++)
for (j = 0; j < 8; j++) dist_col[i][j] = (i == j ? 0 : 10000000);
for (i = 1; i <= n; i++)
for (j = 0; j < 8; j++)
for (k = 0; k < 8; k++)
dist_col[j][k] = min(dist_col[j][k], dist[i][j] + dist[i][k]);
}
void compute_mask() {
int i, j;
for (i = 1; i <= n; i++) {
for (j = 0; j < 8; j++) {
int dif = dist[i][j] - dist_col[s[i] - 'a'][j];
if (dif > 1) cerr << "error";
if (dif == 1) mask[i] |= 1 << j;
}
}
}
int get_dist(int a, int b) {
if (a > b) swap(a, b);
int ans = b - a;
for (int e = 0; e < 8; e++) ans = min(ans, dist[a][e] + 1 + dist[b][e]);
return ans;
}
void update_sol(int val, long long how_many) {
if (how_many == 0) return;
if (val > best) best = val, cnt = 0;
if (val == best) cnt += how_many;
}
void go_to_color(int node, int col, int msk) {
int best = 10000000;
if (enabled[col][msk] == 0) return;
for (int e = 0; e < 8; e++) {
int aux_best = dist[node][e] + 1 + dist_col[col][e] + ((msk >> e) & 1);
best = min(best, aux_best);
}
if (best >= 10000000) return;
update_sol(best, enabled[col][msk]);
}
int main() {
scanf("%d\n%s", &n, s + 1);
for (i = 1; i <= n; i++) wh_col[s[i] - 'a'].push_back(i);
for (i = 0; i < 8; i++) compute_dist(i);
compute_dist_col();
compute_mask();
l = 1;
r = min(n, sp + 1);
for (i = sp + 2; i <= n; i++) enabled[s[i] - 'a'][mask[i]]++;
for (i = 1; i <= n; i++) {
if (l < i - sp && l < i) {
enabled[s[l] - 'a'][mask[l]]++;
l++;
}
if (r < i + sp && r < n) {
r++;
enabled[s[r] - 'a'][mask[r]]--;
}
for (j = l; j <= r; j++) update_sol(get_dist(i, j), 1);
for (j = 0; j < 8; j++)
for (int conf = 0; conf < lim; conf++) go_to_color(i, j, conf);
}
printf("%lld %lld", best, cnt / 2);
return 0;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
You're given a string of lower-case Latin letters. Your task is to find the length of its longest substring that can be met in the string at least twice. These occurrences can overlap (see sample test 2).
Input
The first input line contains the string. It's guaranteed, that the string is non-empty, consists of lower-case Latin letters, and its length doesn't exceed 100.
Output
Output one number — length of the longest substring that can be met in the string at least twice.
Examples
Input
abcd
Output
0
Input
ababa
Output
3
Input
zzz
Output
2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
map<string, int> m;
map<string, int>::iterator it;
int main() {
string s;
cin >> s;
int i, len, ans = 0, x = 0, j;
len = s.length();
for (i = 0; i < len; i++) {
for (j = 1; j < len - i + 1; j++) {
m[s.substr(i, j)]++;
}
}
len = 0;
for (it = m.begin(); it != m.end(); it++) {
s = it->first;
x = it->second;
if (s.length() > len && x >= 2) {
len = s.length();
ans = len;
}
}
cout << ans;
return 0;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
Let S(n) denote the sum of the digits in the decimal notation of n. For example, S(123) = 1 + 2 + 3 = 6.
We will call an integer n a Snuke number when, for all positive integers m such that m > n, \frac{n}{S(n)} \leq \frac{m}{S(m)} holds.
Given an integer K, list the K smallest Snuke numbers.
Constraints
* 1 \leq K
* The K-th smallest Snuke number is not greater than 10^{15}.
Input
Input is given from Standard Input in the following format:
K
Output
Print K lines. The i-th line should contain the i-th smallest Snuke number.
Example
Input
10
Output
1
2
3
4
5
6
7
8
9
19
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < ll(n); i++)
ll sum(ll n) {
ll sum = 0;
while (n > 0) {
sum += n % 10;
n /= 10;
}
return sum;
}
int main() {
ll k;
cin >> k;
ll ans = 1, toAdd = 1;
while (k--) {
cout << ans << endl;
if (sum(ans + toAdd) * (ans + toAdd * 10) < sum(ans + toAdd * 10) * (ans + toAdd))
toAdd *= 10;
ans += toAdd;
}
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
[INSPION FullBand Master - INSPION](https://www.youtube.com/watch?v=kwsciXm_7sA)
[INSPION - IOLITE-SUNSTONE](https://www.youtube.com/watch?v=kwsciXm_7sA)
On another floor of the A.R.C. Markland-N, the young man Simon "Xenon" Jackson, takes a break after finishing his project early (as always). Having a lot of free time, he decides to put on his legendary hacker "X" instinct and fight against the gangs of the cyber world.
His target is a network of n small gangs. This network contains exactly n - 1 direct links, each of them connecting two gangs together. The links are placed in such a way that every pair of gangs is connected through a sequence of direct links.
By mining data, Xenon figured out that the gangs used a form of cross-encryption to avoid being busted: every link was assigned an integer from 0 to n - 2 such that all assigned integers are distinct and every integer was assigned to some link. If an intruder tries to access the encrypted data, they will have to surpass S password layers, with S being defined by the following formula:
$$$S = ∑_{1 ≤ u < v ≤ n} mex(u, v)$$$
Here, mex(u, v) denotes the smallest non-negative integer that does not appear on any link on the unique simple path from gang u to gang v.
Xenon doesn't know the way the integers are assigned, but it's not a problem. He decides to let his AI's instances try all the passwords on his behalf, but before that, he needs to know the maximum possible value of S, so that the AIs can be deployed efficiently.
Now, Xenon is out to write the AI scripts, and he is expected to finish them in two hours. Can you find the maximum possible S before he returns?
Input
The first line contains an integer n (2 ≤ n ≤ 3000), the number of gangs in the network.
Each of the next n - 1 lines contains integers u_i and v_i (1 ≤ u_i, v_i ≤ n; u_i ≠ v_i), indicating there's a direct link between gangs u_i and v_i.
It's guaranteed that links are placed in such a way that each pair of gangs will be connected by exactly one simple path.
Output
Print the maximum possible value of S — the number of password layers in the gangs' network.
Examples
Input
3
1 2
2 3
Output
3
Input
5
1 2
1 3
1 4
3 5
Output
10
Note
In the first example, one can achieve the maximum S with the following assignment:
<image>
With this assignment, mex(1, 2) = 0, mex(1, 3) = 2 and mex(2, 3) = 1. Therefore, S = 0 + 2 + 1 = 3.
In the second example, one can achieve the maximum S with the following assignment:
<image>
With this assignment, all non-zero mex value are listed below:
* mex(1, 3) = 1
* mex(1, 5) = 2
* mex(2, 3) = 1
* mex(2, 5) = 2
* mex(3, 4) = 1
* mex(4, 5) = 3
Therefore, S = 1 + 2 + 1 + 2 + 1 + 3 = 10.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int c = 3002;
int n, dist[c][c], k[c][c], rf[c], f[c];
long long dp[c][c], maxi;
bool v[c];
vector<int> sz[c];
vector<pair<int, int> > d[c];
void dfs(int a) {
v[a] = 1, rf[a] = 1;
for (int i = 0; i < sz[a].size(); i++) {
int x = sz[a][i];
if (!v[x]) {
for (int i = 1; i <= n; i++)
if (dist[a][i]) dist[x][i] = dist[a][i] + 1;
f[x] = a, dfs(x), rf[a] += rf[x];
for (int i = 1; i <= n; i++)
if (dist[x][i] && !dist[a][i]) dist[a][i] = dist[x][i] + 1;
dist[a][x] = 1;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 1; i < n; i++) {
int a, b;
cin >> a >> b;
sz[a].push_back(b), sz[b].push_back(a);
}
dfs(1);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (i != j && !dist[i][j]) dist[i][j] = dist[j][i];
for (int i = 1; i <= n; i++) dist[i][0] = c, dist[0][i] = c;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
int mini = min(rf[i], rf[j]), x = dist[i][j];
int a = rf[i], b = rf[j];
if (dist[f[i]][j] > x)
for (int p = 0; p < sz[i].size(); p++) {
int q = sz[i][p];
if (dist[q][j] < x) a = n - rf[q];
}
if (dist[f[j]][i] > x)
for (int p = 0; p < sz[j].size(); p++) {
int q = sz[j][p];
if (dist[i][q] < x) b = n - rf[q];
}
k[i][j] = a * b;
d[x].push_back({i, j});
}
}
for (int i = 1; i <= n; i++)
for (int j = 0; j < d[i].size(); j++) {
int a = d[i][j].first, b = d[i][j].second;
dp[a][b] += k[a][b], maxi = max(maxi, dp[a][b]);
for (int i = 0; i < sz[a].size(); i++) {
int x = sz[a][i];
dp[x][b] = max(dp[x][b], dp[a][b]);
}
for (int i = 0; i < sz[b].size(); i++) {
int x = sz[b][i];
dp[a][x] = max(dp[a][x], dp[a][b]);
}
}
cout << maxi << "\n";
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
Consider writing each of the integers from 1 to N \times M in a grid with N rows and M columns, without duplicates. Takahashi thinks it is not fun enough, and he will write the numbers under the following conditions:
* The largest among the values in the i-th row (1 \leq i \leq N) is A_i.
* The largest among the values in the j-th column (1 \leq j \leq M) is B_j.
For him, find the number of ways to write the numbers under these conditions, modulo 10^9 + 7.
Constraints
* 1 \leq N \leq 1000
* 1 \leq M \leq 1000
* 1 \leq A_i \leq N \times M
* 1 \leq B_j \leq N \times M
* A_i and B_j are integers.
Input
Input is given from Standard Input in the following format:
N M
A_1 A_2 ... A_{N}
B_1 B_2 ... B_{M}
Output
Print the number of ways to write the numbers under the conditions, modulo 10^9 + 7.
Examples
Input
2 2
4 3
3 4
Output
2
Input
3 3
5 9 7
3 6 9
Output
0
Input
2 2
4 4
4 4
Output
0
Input
14 13
158 167 181 147 178 151 179 182 176 169 180 129 175 168
181 150 178 179 167 180 176 169 182 177 175 159 173
Output
343772227
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
const int mod=1e9+7;
int n,m,r[2201],c[2201],rslot[2201],cslot[2201];
int main()
{
cin>>n>>m;
for(int i=1;i<=n;i++)cin>>r[i];
for(int i=1;i<=m;i++)cin>>c[i];
sort(r+1,r+1+n);
sort(c+1,c+1+m);
int p1=n,p2=m;
long long ans=1;
for(int i=n*m,full=0;i;i--,full++)
if(r[p1]==i&&c[p2]==i)p1--,p2--;
else if(r[p1]==i)
{
p1--;
ans=ans*(m-p2)%mod;
}
else if(c[p2]==i)
{
p2--;
ans=ans*(n-p1)%mod;
}
else ans=ans*((n-p1)*(m-p2)-full)%mod;
cout<<ans<<'\n';
}
``` |
### Prompt
Create a solution in CPP for the following problem:
Polycarp has a favorite sequence a[1 ... n] consisting of n integers. He wrote it out on the whiteboard as follows:
* he wrote the number a_1 to the left side (at the beginning of the whiteboard);
* he wrote the number a_2 to the right side (at the end of the whiteboard);
* then as far to the left as possible (but to the right from a_1), he wrote the number a_3;
* then as far to the right as possible (but to the left from a_2), he wrote the number a_4;
* Polycarp continued to act as well, until he wrote out the entire sequence on the whiteboard.
<image> The beginning of the result looks like this (of course, if n ≥ 4).
For example, if n=7 and a=[3, 1, 4, 1, 5, 9, 2], then Polycarp will write a sequence on the whiteboard [3, 4, 5, 2, 9, 1, 1].
You saw the sequence written on the whiteboard and now you want to restore Polycarp's favorite sequence.
Input
The first line contains a single positive integer t (1 ≤ t ≤ 300) — the number of test cases in the test. Then t test cases follow.
The first line of each test case contains an integer n (1 ≤ n ≤ 300) — the length of the sequence written on the whiteboard.
The next line contains n integers b_1, b_2,…, b_n (1 ≤ b_i ≤ 10^9) — the sequence written on the whiteboard.
Output
Output t answers to the test cases. Each answer — is a sequence a that Polycarp wrote out on the whiteboard.
Example
Input
6
7
3 4 5 2 9 1 1
4
9 2 7 1
11
8 4 3 1 2 7 8 7 9 4 2
1
42
2
11 7
8
1 1 1 1 1 1 1 1
Output
3 1 4 1 5 9 2
9 1 2 7
8 2 4 4 3 9 1 7 2 8 7
42
11 7
1 1 1 1 1 1 1 1
Note
In the first test case, the sequence a matches the sequence from the statement. The whiteboard states after each step look like this:
[3] ⇒ [3, 1] ⇒ [3, 4, 1] ⇒ [3, 4, 1, 1] ⇒ [3, 4, 5, 1, 1] ⇒ [3, 4, 5, 9, 1, 1] ⇒ [3, 4, 5, 2, 9, 1, 1].
### Response
```cpp
#include <iostream>
using namespace std;
int main()
{
int t, n, x, y, ch, old[300], gold[300];
for (int i = 0; i < 300; i++)
{
gold[i] = 0;
old[i] = 0;
}
cin >> t;
for (int i = 1; i <= t; i++)
{
cin >> n;
for (int p = 0; p < n; p++)
cin >> old[p];
x = 0;
y = n - 1;
ch = 1;
while (ch != n + 1)
{
if (ch % 2 != 0)
{
gold[ch - 1] = old[x];
x++;
}
else
{
gold[ch - 1] = old[y];
y--;
}
ch++;
}
for (int p = 0; p < n; p++)
cout << gold[p] << " ";
cout << endl;
}
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
Vasya has written some permutation p_1, p_2, …, p_n of integers from 1 to n, so for all 1 ≤ i ≤ n it is true that 1 ≤ p_i ≤ n and all p_1, p_2, …, p_n are different. After that he wrote n numbers next_1, next_2, …, next_n. The number next_i is equal to the minimal index i < j ≤ n, such that p_j > p_i. If there is no such j let's let's define as next_i = n + 1.
In the evening Vasya went home from school and due to rain, his notebook got wet. Now it is impossible to read some written numbers. Permutation and some values next_i are completely lost! If for some i the value next_i is lost, let's say that next_i = -1.
You are given numbers next_1, next_2, …, next_n (maybe some of them are equal to -1). Help Vasya to find such permutation p_1, p_2, …, p_n of integers from 1 to n, that he can write it to the notebook and all numbers next_i, which are not equal to -1, will be correct.
Input
The first line contains one integer t — the number of test cases (1 ≤ t ≤ 100 000).
Next 2 ⋅ t lines contains the description of test cases,two lines for each. The first line contains one integer n — the length of the permutation, written by Vasya (1 ≤ n ≤ 500 000). The second line contains n integers next_1, next_2, …, next_n, separated by spaces (next_i = -1 or i < next_i ≤ n + 1).
It is guaranteed, that the sum of n in all test cases doesn't exceed 500 000.
In hacks you can only use one test case, so T = 1.
Output
Print T lines, in i-th of them answer to the i-th test case.
If there is no such permutations p_1, p_2, …, p_n of integers from 1 to n, that Vasya could write, print the only number -1.
In the other case print n different integers p_1, p_2, …, p_n, separated by spaces (1 ≤ p_i ≤ n). All defined values of next_i which are not equal to -1 should be computed correctly p_1, p_2, …, p_n using defenition given in the statement of the problem. If there exists more than one solution you can find any of them.
Example
Input
6
3
2 3 4
2
3 3
3
-1 -1 -1
3
3 4 -1
1
2
4
4 -1 4 5
Output
1 2 3
2 1
2 1 3
-1
1
3 2 1 4
Note
In the first test case for permutation p = [1, 2, 3] Vasya should write next = [2, 3, 4], because each number in permutation is less than next. It's easy to see, that it is the only satisfying permutation.
In the third test case, any permutation can be the answer because all numbers next_i are lost.
In the fourth test case, there is no satisfying permutation, so the answer is -1.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
constexpr int MAX_N = 524288;
int T;
int n;
array<int, 2 * MAX_N> segment;
array<int, MAX_N> nextPos;
array<int, MAX_N> answer;
vector<int> stck;
void update(int pos, int val) {
int i = MAX_N + pos;
segment[i] = val;
i /= 2;
while (i > 0) segment[i] = segment[2 * i] + segment[2 * i + 1], i /= 2;
}
void reset() {
for (int i = 0; i < n; ++i) update(i, 0);
for (int i = 0; i < n; ++i) nextPos[i] = 0;
for (int i = 0; i < n; ++i) answer[i] = 0;
stck.clear();
}
int getSum(int meFrom, int meTo, int from, int to, int pos) {
if (from >= to) return 0;
if (meTo <= from) return 0;
if (to <= meFrom) return 0;
if (from <= meFrom && meTo <= to) return segment[pos];
int mid = (meFrom + meTo) / 2;
return getSum(meFrom, mid, from, to, 2 * pos) +
getSum(mid, meTo, from, to, 2 * pos + 1);
}
int main() {
std::ios::sync_with_stdio(false);
cin >> T;
for (int testCase = 1; testCase <= T; ++testCase) {
cin >> n;
for (int i = 0; i < n; ++i) cin >> nextPos[i];
for (int i = 0; i < n; ++i)
if (nextPos[i] == -1)
nextPos[i] = i + 1;
else
nextPos[i] -= 1;
bool ok = true;
int val = n;
for (int i = 0; i < n && ok; ++i)
if (answer[i] == 0) {
int nextIdx = nextPos[i];
stck.push_back(i);
update(i, 1);
if (getSum(0, MAX_N, stck.back() + 1, nextIdx, 1) != 0) ok = false;
while (nextIdx != n && answer[nextIdx] == 0 && ok) {
stck.push_back(nextIdx);
update(nextIdx, 1);
nextIdx = nextPos[nextIdx];
if (getSum(0, MAX_N, stck.back() + 1, nextIdx, 1) != 0) ok = false;
}
while (!stck.empty() && ok)
answer[stck.back()] = val, val -= 1, stck.pop_back();
}
if (ok) {
for (int i = 0; i < n; ++i) cout << answer[i] << ' ';
cout << '\n';
} else
cout << -1 << endl;
reset();
}
return 0;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
Alice, Bob and Charlie are playing Card Game for Three, as below:
* At first, each of the three players has a deck consisting of some number of cards. Alice's deck has N cards, Bob's deck has M cards, and Charlie's deck has K cards. Each card has a letter `a`, `b` or `c` written on it. The orders of the cards in the decks cannot be rearranged.
* The players take turns. Alice goes first.
* If the current player's deck contains at least one card, discard the top card in the deck. Then, the player whose name begins with the letter on the discarded card, takes the next turn. (For example, if the card says `a`, Alice takes the next turn.)
* If the current player's deck is empty, the game ends and the current player wins the game.
There are 3^{N+M+K} possible patters of the three player's initial decks. Among these patterns, how many will lead to Alice's victory?
Since the answer can be large, print the count modulo 1\,000\,000\,007 (=10^9+7).
Constraints
* 1 \leq N \leq 3×10^5
* 1 \leq M \leq 3×10^5
* 1 \leq K \leq 3×10^5
Input
The input is given from Standard Input in the following format:
N M K
Output
Print the answer modulo 1\,000\,000\,007 (=10^9+7).
Examples
Input
1 1 1
Output
17
Input
4 2 2
Output
1227
Input
1000 1000 1000
Output
261790852
### Response
```cpp
#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
const int MAXN = 9e5 + 10 , MOD = 1e9 + 7;
int fac[MAXN] , ifac[MAXN] , f3[MAXN];
void init(){
fac[0] = fac[1] = 1;
for(int i = 2 ; i < MAXN ; ++ i)
fac[i] = 1ll * fac[i - 1] * i % MOD;
ifac[0] = ifac[1] = 1;
for(int i = 2 ; i < MAXN ; ++ i)
ifac[i] = MOD - 1ll * ifac[MOD % i] * (MOD / i) % MOD;
for(int i = 2 ; i < MAXN ; ++ i)
ifac[i] = 1ll * ifac[i - 1] * ifac[i] % MOD;
f3[0] = 1;
for(int i = 1 ; i < MAXN ; ++ i)
f3[i] = 1ll * f3[i - 1] * 3 % MOD;
}
int C(int a , int b){
if(b < 0 || b > a) return 0;
return 1ll * fac[a] * ifac[b] % MOD * ifac[a - b] % MOD;
}
int n , m , k;
int main(){
init();
cin >> n >> m >> k;
int ans = 0 , last = 1 , st = 0 , ed = 0;
for(int i = 0 ; i <= m + k ; ++ i){
ans = (ans + 1ll * last * f3[m + k - i] % MOD * C(n + i - 1 , n - 1)) % MOD;
last = 2ll * last % MOD;
last = (last + C(i , st - 1)) % MOD;
last = (last + MOD - C(i , ed)) % MOD;
if(i - st >= m){
last = (last + MOD - C(i + 1 , st)) % MOD;
st ++;
}
if(ed < k){
ed ++;
last = (last + C(i + 1 , ed)) % MOD;
}
if(st > ed) break;
}
cout << ans << endl;
return 0;
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
Scores of Final Examination
I am a junior high school teacher. The final examination has just finished, and I have all the students' scores of all the subjects. I want to know the highest total score among the students, but it is not an easy task as the student scores are listed separately for each subject. I would like to ask you, an excellent programmer, to help me by writing a program that finds the total score of a student with the highest total score.
Input
The input consists of multiple datasets, each in the following format.
> n m
> p1,1 p1,2 … p1,n
> p2,1 p2,2 … p2,n
> …
> pm,1 pm,2 … pm,n
>
The first line of a dataset has two integers n and m. n is the number of students (1 ≤ n ≤ 1000). m is the number of subjects (1 ≤ m ≤ 50). Each of the following m lines gives n students' scores of a subject. pj,k is an integer representing the k-th student's score of the subject j (1 ≤ j ≤ m and 1 ≤ k ≤ n). It satisfies 0 ≤ pj,k ≤ 1000.
The end of the input is indicated by a line containing two zeros. The number of datasets does not exceed 100.
Output
For each dataset, output the total score of a student with the highest total score. The total score sk of the student k is defined by sk = p1,k + … + pm,k.
Sample Input
5 2
10 20 30 40 50
15 25 35 45 55
6 3
10 20 30 15 25 35
21 34 11 52 20 18
31 15 42 10 21 19
4 2
0 0 0 0
0 0 0 0
0 0
Output for the Sample Input
105
83
0
Example
Input
5 2
10 20 30 40 50
15 25 35 45 55
6 3
10 20 30 15 25 35
21 34 11 52 20 18
31 15 42 10 21 19
4 2
0 0 0 0
0 0 0 0
0 0
Output
105
83
0
### Response
```cpp
#include <bits/stdc++.h>
typedef long long ll;
#define ALL(a) a, a+sizeof(a)/sizeof(a[0])
#define all(a) a.begin(),a.end()
#define MOD 1000000007
using namespace std;
ll gcd(ll n, ll m) {
if (m == 0) return n;
return gcd(m, n % m);
}
ll lcm(ll n, ll m) {return m / gcd(n, m) * n;}
int main(void) {
int n,m,tmp;
while (1) {
cin >> n >> m;
if (n == 0 && m == 0) break;
vector<int> point(n);
for (int i = 0; i < n; i++) point[i] = 0;
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
cin >> tmp;
point[j] += tmp;
}
}
cout << *max_element(all(point)) << "\n";
}
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
The final round of Bayan Programming Contest will be held in Tehran, and the participants will be carried around with a yellow bus. The bus has 34 passenger seats: 4 seats in the last row and 3 seats in remaining rows.
<image>
The event coordinator has a list of k participants who should be picked up at the airport. When a participant gets on the bus, he will sit in the last row with an empty seat. If there is more than one empty seat in that row, he will take the leftmost one.
In order to keep track of the people who are on the bus, the event coordinator needs a figure showing which seats are going to be taken by k participants. Your task is to draw the figure representing occupied seats.
Input
The only line of input contains integer k, (0 ≤ k ≤ 34), denoting the number of participants.
Output
Print the figure of a bus with k passengers as described in sample tests. Character '#' denotes an empty seat, while 'O' denotes a taken seat. 'D' is the bus driver and other characters in the output are for the purpose of beautifying the figure. Strictly follow the sample test cases output format. Print exactly six lines. Do not output extra space or other characters.
Examples
Input
9
Output
+------------------------+
|O.O.O.#.#.#.#.#.#.#.#.|D|)
|O.O.O.#.#.#.#.#.#.#.#.|.|
|O.......................|
|O.O.#.#.#.#.#.#.#.#.#.|.|)
+------------------------+
Input
20
Output
+------------------------+
|O.O.O.O.O.O.O.#.#.#.#.|D|)
|O.O.O.O.O.O.#.#.#.#.#.|.|
|O.......................|
|O.O.O.O.O.O.#.#.#.#.#.|.|)
+------------------------+
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string a[6] = {"+------------------------+", "|#.#.#.#.#.#.#.#.#.#.#.|D|)",
"|#.#.#.#.#.#.#.#.#.#.#.|.|", "|#.......................|",
"|#.#.#.#.#.#.#.#.#.#.#.|.|)", "+------------------------+"};
switch (n) {
case 34:
a[4][21] = 'O';
case 33:
a[2][21] = 'O';
case 32:
a[1][21] = 'O';
case 31:
a[4][19] = 'O';
case 30:
a[2][19] = 'O';
case 29:
a[1][19] = 'O';
case 28:
a[4][17] = 'O';
case 27:
a[2][17] = 'O';
case 26:
a[1][17] = 'O';
case 25:
a[4][15] = 'O';
case 24:
a[2][15] = 'O';
case 23:
a[1][15] = 'O';
case 22:
a[4][13] = 'O';
case 21:
a[2][13] = 'O';
case 20:
a[1][13] = 'O';
case 19:
a[4][11] = 'O';
case 18:
a[2][11] = 'O';
case 17:
a[1][11] = 'O';
case 16:
a[4][9] = 'O';
case 15:
a[2][9] = 'O';
case 14:
a[1][9] = 'O';
case 13:
a[4][7] = 'O';
case 12:
a[2][7] = 'O';
case 11:
a[1][7] = 'O';
case 10:
a[4][5] = 'O';
case 9:
a[2][5] = 'O';
case 8:
a[1][5] = 'O';
case 7:
a[4][3] = 'O';
case 6:
a[2][3] = 'O';
case 5:
a[1][3] = 'O';
case 4:
a[4][1] = 'O';
case 3:
a[3][1] = 'O';
case 2:
a[2][1] = 'O';
case 1:
a[1][1] = 'O';
}
for (n = 0; n < 6; n++) cout << a[n] << endl;
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
Vitya loves programming and problem solving, but sometimes, to distract himself a little, he plays computer games. Once he found a new interesting game about tanks, and he liked it so much that he went through almost all levels in one day. Remained only the last level, which was too tricky. Then Vitya remembered that he is a programmer, and wrote a program that helped him to pass this difficult level. Try do the same.
The game is organized as follows. There is a long road, two cells wide and n cells long. Some cells have obstacles. You control a tank that occupies one cell. Initially, the tank is located before the start of the road, in a cell with coordinates (0, 1). Your task is to move the tank to the end of the road, to the cell (n + 1, 1) or (n + 1, 2).
<image>
Every second the tank moves one cell to the right: the coordinate x is increased by one. When you press the up or down arrow keys, the tank instantly changes the lane, that is, the y coordinate. When you press the spacebar, the tank shoots, and the nearest obstacle along the lane in which the tank rides is instantly destroyed. In order to load a gun, the tank needs t seconds. Initially, the gun is not loaded, that means, the first shot can be made only after t seconds after the tank starts to move.
If at some point the tank is in the same cell with an obstacle not yet destroyed, it burns out. If you press the arrow exactly at the moment when the tank moves forward, the tank will first move forward, and then change the lane, so it will not be possible to move diagonally.
Your task is to find out whether it is possible to pass the level, and if possible, to find the order of actions the player need to make.
Input
The first line contains four integers n, m1, m2 and t, the length of the field, the number of obstacles in the first lane, the number of obstacles in the second lane and the number of tank steps before reloading, respectively (1 ≤ n ≤ 109; 0 ≤ m1, m2 ≤ n; 0 ≤ m1 + m2 ≤ 106; 1 ≤ t ≤ n).
The next two lines contain a description of the obstacles. The first of these lines contains m1 numbers xi — the obstacle coordinates in the first lane (1 ≤ xi ≤ n; xi < xi + 1). The y coordinate for all these obstacles will be 1.
The second line contains m2 numbers describing the obstacles of the second lane in the same format. The y coordinate of all these obstacles will be 2.
Output
In the first line print «Yes», if it is possible to pass the level, or «No», otherwise.
If it is possible, then in the second line print the number of times the tank moves from one lane to another, and in the next line print the coordinates of the transitions, one number per transition: the coordinate x (0 ≤ x ≤ n + 1). All transition coordinates coordinates must be distinct and should be output in strictly increasing order.The number of transitions should not exceed 2·106. If the tank can pass the level, then it can do it using no more than 2·106 transitions.
In the fourth line print the number of shots that the tank makes during the movement, in the following lines print two numbers, x and y coordinates of the point (1 ≤ x ≤ n, 1 ≤ y ≤ 2), from which the tank fired a shot, the number of shots must not exceed m1 + m2. Shots must be output in the order in which they are fired.
If there are several solutions, output any one.
Examples
Input
6 2 3 2
2 6
3 5 6
Output
Yes
2
0 3
2
2 2
4 1
Input
1 1 1 1
1
1
Output
No
Input
9 5 2 5
1 2 7 8 9
4 6
Output
Yes
4
0 3 5 10
1
5 2
Note
Picture for the first sample test.
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1LL << 60;
int main() {
int n, m1, m2, t;
scanf("%d%d%d%d", &n, &m1, &m2, &t);
map<int, int> has;
map<int, int> change[2], change2[2];
map<int, long long> tab[2];
for (int i = 0; i < m1; ++i) {
int x;
scanf("%d", &x);
has[x] |= 1;
}
for (int i = 0; i < m2; ++i) {
int x;
scanf("%d", &x);
has[x] |= 2;
}
long long f = 0, g = INF;
long long px = -1;
for (auto e : has) {
long long x = e.first;
int typ = e.second;
if (x > px + 1) {
long long tf = f, tg = g;
long long v = max(px + 1 - t, tg);
if (v < f) {
f = v;
change2[0][x] = px + 1;
}
v = max(px + 1 - t, tf);
if (v < g) {
g = v;
change2[1][x] = px + 1;
}
}
if (typ == 1) {
if (f + t < x)
f += t;
else
f = INF;
long long v = max(x - t, f);
if (v < g) {
g = v;
change[1][x] = x;
}
} else if (typ == 2) {
if (g + t < x)
g += t;
else
g = INF;
long long v = max(x - t, g);
if (v < f) {
f = v;
change[0][x] = x;
}
} else {
if (f + t < x)
f += t;
else
f = INF;
if (g + t < x)
g += t;
else
g = INF;
}
tab[0][x] = f;
tab[1][x] = g;
px = x;
}
const long long SINF = (1LL << 40);
if (f > SINF && g > SINF)
printf("No\n");
else {
int lane = (g <= SINF);
vector<int> transits;
vector<pair<int, int>> shots;
for (auto it = has.rbegin(); it != has.rend(); ++it) {
long long x = it->first;
int typ = it->second;
if (change[lane][x]) {
transits.push_back(x);
lane = 1 - lane;
}
if (typ & (1 << lane)) {
shots.push_back({tab[lane][x], lane + 1});
}
if (change2[lane].count(x)) {
transits.push_back(change2[lane][x]);
lane = 1 - lane;
}
}
reverse(shots.begin(), shots.end());
reverse(transits.begin(), transits.end());
printf("Yes\n");
printf("%d\n", transits.size());
for (int x : transits) printf("%d ", x);
printf("\n");
printf("%d\n", shots.size());
for (auto x : shots) printf("%d %d\n", x.first, x.second);
}
}
``` |
### Prompt
Create a solution in CPP for the following problem:
Mr. Infinity has a string S consisting of digits from `1` to `9`. Each time the date changes, this string changes as follows:
* Each occurrence of `2` in S is replaced with `22`. Similarly, each `3` becomes `333`, `4` becomes `4444`, `5` becomes `55555`, `6` becomes `666666`, `7` becomes `7777777`, `8` becomes `88888888` and `9` becomes `999999999`. `1` remains as `1`.
For example, if S is `1324`, it becomes `1333224444` the next day, and it becomes `133333333322224444444444444444` the day after next. You are interested in what the string looks like after 5 \times 10^{15} days. What is the K-th character from the left in the string after 5 \times 10^{15} days?
Constraints
* S is a string of length between 1 and 100 (inclusive).
* K is an integer between 1 and 10^{18} (inclusive).
* The length of the string after 5 \times 10^{15} days is at least K.
Input
Input is given from Standard Input in the following format:
S
K
Output
Print the K-th character from the left in Mr. Infinity's string after 5 \times 10^{15} days.
Examples
Input
1214
4
Output
2
Input
3
157
Output
3
Input
299792458
9460730472580800
Output
2
### Response
```cpp
#include <iostream>
#include <string>
using namespace std;
int main(){long long K,an=0;string S;cin >> S >> K;while (an<K-1&&S.at(an) == '1'){an++;}cout << S.at(an) << endl;}
``` |
### Prompt
Your challenge is to write 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 namespace std;
const int oo = 1000000009;
const double eps = 1e-9;
const int mod = 1000000007;
int parents[100001], child[100001], cnt[100001], dst[100001];
bool visited[100001];
vector<pair<int, int> > edge[100001];
void bfs() {
int temp, ver, pos;
queue<int> mq;
mq.push(1);
for (int i = 2; i < 100001 + 1; ++i) cnt[i] = 1e9;
visited[1] = true;
while (!mq.empty()) {
temp = mq.front();
mq.pop();
for (int i = 0; i < edge[temp].size(); ++i) {
ver = edge[temp][i].first;
pos = edge[temp][i].second;
if (!visited[ver]) {
dst[ver] = 1 + dst[temp];
cnt[ver] = (1 - pos) + cnt[temp];
mq.push(ver);
visited[ver] = true;
}
if (dst[ver] >= 1 + dst[temp] && cnt[ver] >= cnt[temp] + !pos) {
cnt[ver] = cnt[temp] + !pos;
parents[ver] = temp;
}
}
}
}
int main() {
int n, m, a, b, c, z, o;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
scanf("%d%d%d", &a, &b, &c);
edge[a].push_back(make_pair(b, c));
edge[b].push_back(make_pair(a, c));
if (c)
++o;
else
++z;
}
bfs();
int papa = n, ver, pos;
cout << (o + 2 * cnt[papa] - dst[papa]) << "\n";
while (parents[papa] != 0) {
child[parents[papa]] = papa;
papa = parents[papa];
}
for (int i = 1; i < n + 1; ++i) {
for (int j = 0; j < edge[i].size(); ++j) {
ver = edge[i][j].first;
pos = edge[i][j].second;
if (ver > i) {
if ((child[i] == ver || child[ver] == i) && pos == 0)
printf("%d %d 1\n", i, ver);
else if (child[i] != ver && child[ver] != i && pos == 1)
printf("%d %d 0\n", i, ver);
}
}
}
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
There are n glasses on the table numbered 1, …, n. The glass i can hold up to a_i units of water, and currently contains b_i units of water.
You would like to choose k glasses and collect as much water in them as possible. To that effect you can pour water from one glass to another as many times as you like. However, because of the glasses' awkward shape (and totally unrelated to your natural clumsiness), each time you try to transfer any amount of water, half of the amount is spilled on the floor.
Formally, suppose a glass i currently contains c_i units of water, and a glass j contains c_j units of water. Suppose you try to transfer x units from glass i to glass j (naturally, x can not exceed c_i). Then, x / 2 units is spilled on the floor. After the transfer is done, the glass i will contain c_i - x units, and the glass j will contain min(a_j, c_j + x / 2) units (excess water that doesn't fit in the glass is also spilled).
Each time you transfer water, you can arbitrarlly choose from which glass i to which glass j to pour, and also the amount x transferred can be any positive real number.
For each k = 1, …, n, determine the largest possible total amount of water that can be collected in arbitrarily chosen k glasses after transferring water between glasses zero or more times.
Input
The first line contains a single integer n (1 ≤ n ≤ 100) — the number of glasses.
The following n lines describe the glasses. The i-th of these lines contains two integers a_i and b_i (0 ≤ b_i ≤ a_i ≤ 100, a_i > 0) — capacity, and water amount currently contained for the glass i, respectively.
Output
Print n real numbers — the largest amount of water that can be collected in 1, …, n glasses respectively. Your answer will be accepted if each number is within 10^{-9} absolute or relative tolerance of the precise answer.
Example
Input
3
6 5
6 5
10 2
Output
7.0000000000 11.0000000000 12.0000000000
Note
In the sample case, you can act as follows:
* for k = 1, transfer water from the first two glasses to the third one, spilling (5 + 5) / 2 = 5 units and securing 2 + (5 + 5) / 2 = 7 units;
* for k = 2, transfer water from the third glass to any of the first two, spilling 2 / 2 = 1 unit and securing 5 + 5 + 2 / 2 = 11 units;
* for k = 3, do nothing. All 5 + 5 + 2 = 12 units are secured.
### Response
```cpp
#include <bits/stdc++.h>
// #pragma GCC optimize("Ofast")
using namespace std;
using ll = int64_t;
using ar2 = array<int, 2>;
template <typename T>
using min_heap = priority_queue<T, vector<T>, greater<T>>;
template <typename T>
using max_heap = priority_queue<T>;
const int thicc = 1e9 + 10, smol = -thicc;
const ll rilly_thicc = 1e18 + 10, rilly_smol = -rilly_thicc;
const int maxn = 2e2 + 10;
int a[maxn], b[maxn], dp[maxn][maxn * maxn];
int n;
void solve() {
scanf("%d", &n);
int sum = 0;
for (int i = 0; i < n; i++)
scanf("%d", &a[i]), a[i] *= 2, scanf("%d", &b[i]), b[i] *= 2, sum += b[i];
int total = accumulate(a, a + n, 0);
memset(dp, 0x80, sizeof(dp));
dp[0][0] = 0;
for (int i = n - 1; i >= 0; i--) {
for (int j = n; j >= 1; j--) {
for (int k = total; k >= a[i]; --k) {
dp[j][k] = max(dp[j][k], dp[j - 1][k - a[i]] + b[i]);
}
}
}
// for (int i = 1; i <= 60; ++i) {
// printf("%2d ", i);
// }
// puts("");
// for (int j = 1; j <= n; ++j) {
// for (int k = 1; k <= 60; ++k) {
// printf("%2d ", dp[j][k] < 0 ? -1 : dp[j][k]);
// }
// puts("");
// }
// puts("");
// printf("%d\n", dp[1][200]);
for (int j = 1; j <= n; ++j) {
int ans = 0;
for (int k = 0; k <= total; ++k) {
if (dp[j][k] >= 0) ans = max(ans, min(k, sum / 2 + dp[j][k] / 2));
}
printf("%.3f ", ans / 2.);
}
}
int main() {
int tc = 1;
// scanf("%d", &tc);
for (int i = 1; i <= tc; ++i) {
// printf("Case #%d: ", i);
solve();
}
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
curtain
Summer is coming soon. You decide to redecorate your room for the summer. It is expected that the sun will be very strong this summer, and it will be a difficult season for you who are not good at dazzling. So you thought about installing a curtain on the window of the room to adjust the brightness of the room.
The curtain to be attached is rectangular and is attached so that the sides are perpendicular to or parallel to the ground. Also, the windows in your room have a very special shape and are represented by N-sided polygons where each side is parallel or perpendicular to the ground. Therefore, it is difficult to determine the area of a window that is not covered by the curtain when the curtain is attached. In order to adjust the brightness of the room, it is important to know how much the window can cover when deciding where to install the curtain. So you decided to create a program to find the area of a window that is not covered by a curtain, given the location and shape of the window and curtain.
As an example, consider the following method of installing windows and curtains. In this case, the area of the window not hidden by the curtain is 8. This example corresponds to the third case of sample input.
<image>
Input
The input consists of multiple datasets. Each dataset is given in the following format.
> N
> x1 y1
>::
>::
> xN yN
> a1 b1
> a2 b2
> a3 b3
> a4 b4
The first line is given the integer N, which represents the number of vertices the window has (4 ≤ N ≤ 100). The following N lines are given the integer xi representing the x-coordinates of the different vertices of the window and the integer yi representing the y-coordinate (-20,000 ≤ xi, yi ≤ 20,000, 1 ≤ i ≤ N). Here, the positive direction of the y-axis is the direction rotated 90 degrees counterclockwise from the positive direction of the x-axis. In addition, the next four lines are given the integer aj, which represents the x-coordinate of the different vertices of the curtain, and the integer bj, which represents the y-coordinate (-20,000 ≤ aj, bj ≤ 20,000, 1 ≤ j ≤ 4). The vertices of both windows and curtains are given in counterclockwise order. In addition, the figures representing windows and curtains are figures without self-intersection.
The end of the input is indicated by a single 0 line.
Output
For each dataset, output the area of the window not covered by the curtain on one line. However, note that the area is always an integer value.
Sample Input
Four
0 0
10 0
10 10
0 10
0 0
5 0
5 10
0 10
6
0 0
10 0
10 5
5 5
5 10
0 10
2 0
8 0
8 10
2 10
12
1 1
13
-13
-1 1
-3 1
-3 -1
-1 -1
-13
13
1 -1
3 -1
3 1
twenty two
-twenty two
-twenty two
twenty two
Four
20000 20000
-20000 20000
-20000 -20000
20000 -20000
1000 1000
-1000 1000
-1000 -1000
1000 -1000
Four
1000 1000
-1000 1000
-1000 -1000
1000 -1000
20000 20000
-20000 20000
-20000 -20000
20000 -20000
Four
0 0
10 0
10 10
0 10
20 0
30 0
30 10
20 10
0
Output for Sample Input
50
30
8
1596000000
0
100
Example
Input
4
0 0
10 0
10 10
0 10
0 0
5 0
5 10
0 10
6
0 0
10 0
10 5
5 5
5 10
0 10
2 0
8 0
8 10
2 10
12
1 1
1 3
-1 3
-1 1
-3 1
-3 -1
-1 -1
-1 -3
1 -3
1 -1
3 -1
3 1
2 2
-2 2
-2 -2
2 -2
4
20000 20000
-20000 20000
-20000 -20000
20000 -20000
1000 1000
-1000 1000
-1000 -1000
1000 -1000
4
1000 1000
-1000 1000
-1000 -1000
1000 -1000
20000 20000
-20000 20000
-20000 -20000
20000 -20000
4
0 0
10 0
10 10
0 10
20 0
30 0
30 10
20 10
0
Output
50
30
8
1596000000
0
100
### Response
```cpp
#include<iomanip>
#include<limits>
#include<thread>
#include<utility>
#include<iostream>
#include<string>
#include<algorithm>
#include<set>
#include<map>
#include<vector>
#include<stack>
#include<queue>
#include<cmath>
#include<numeric>
#include<cassert>
#include<random>
#include<chrono>
#include<unordered_set>
#include<unordered_map>
#include<fstream>
#include<list>
#include<functional>
#include<bitset>
#include<complex>
#include<tuple>
using namespace std;
typedef unsigned long long int ull;
typedef long long int ll;
typedef pair<ll,ll> pll;
typedef long double D;
#define F first
#define S second
const ll E=1e18+7;
const ll MOD=1000000007;
int main(){
ll n;
while(cin>>n){
if(n==0){break;}
vector<pll> A(n);
const ll C=30000;
for(auto &I:A){cin>>I.F>>I.S; I.S+=C;}
vector<pair<pair<ll,ll>,pll>> B;
for(int i=1;i<=n;i++){
if(A[i%n].F==A[i-1].F){
if(A[i-1].S<A[i%n].S){B.push_back({{A[i%n].F,3},{A[i-1].S,A[i%n].S}});}
else{B.push_back({{A[i%n].F,2},{A[i%n].S,A[i-1].S}});}
}
}
vector<pll> S(4);
for(auto &I:S){cin>>I.F>>I.S; I.S+=C;}
for(int i=1;i<=4;i++){
if(S[i%4].F==S[i-1].F){
if(S[i-1].S<S[i%4].S){B.push_back({{S[i%4].F,1},{S[i-1].S,S[i%4].S}});}
else{B.push_back({{S[i%4].F,0},{S[i%4].S,S[i-1].S}});}
}
}
sort(B.begin(),B.end());
vector<bool> in(2*C,false);
vector<bool> sq(2*C,false);
ll bef=-E;
ll ans=0;
for(auto &I:B){
for(int i=0;i<2*C;i++){
if(in[i] && !sq[i]){ans+=I.F.F-bef;}
}
if(I.F.S>>1&1){
for(ll i=I.S.F;i<I.S.S;i++){in[i]=!in[i];}
}
else{
for(ll i=I.S.F;i<I.S.S;i++){sq[i]=!sq[i];}
}
bef=I.F.F;
//cout<<bef<<" "<<ans<<endl;
}
cout<<ans<<endl;
}
return 0;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
Problem
Yamano Mifune Gakuen's 1st grade G group is a class where female students carrying misfortune gather. They face various challenges every day with the goal of being happy.
In their class, they can take practical happiness courses as part of the test of happiness.
From Monday to Friday, there are classes from 1st to Nth, and there are M courses that can be taken.
Subject i starts from the ai period of the day of the week di (di = 0, 1, 2, 3, 4 corresponds to Monday, Tuesday, Wednesday, Thursday, and Friday, respectively), and is performed in consecutive ki frames. The degree of happiness obtained when taking the course is ti.
Each student is free to choose up to L subjects so that they do not overlap each other. How do you choose the subject to get the highest level of happiness? Please find the maximum value of happiness that can be obtained from the information of the given subject.
Constraints
* 2 ≤ N ≤ 8
* 0 ≤ M ≤ 300
* 0 ≤ L ≤ min (N × 5, M)
* 0 ≤ di ≤ 4
* 1 ≤ ai ≤ N
* 1 ≤ ki
* ai + ki --1 ≤ N
* 1 ≤ ti ≤ 100
Input
The input is given in the following format.
N M L
d1 a1 k1 t1
d2 a2 k2 t2
...
dM aM kM tM
The first line is given three integers N, M, L separated by blanks.
The four integers di, ai, ki, and ti are given on the 2nd to M + 1th lines, separated by blanks.
Output
Output the maximum value of the sum of happiness on one line.
Examples
Input
3 7 3
0 1 1 1
0 1 1 2
1 1 3 4
1 1 1 1
1 2 1 2
2 1 1 3
2 2 2 1
Output
9
Input
5 10 5
0 1 1 2
0 2 1 2
0 1 2 3
1 2 1 2
1 4 2 3
2 1 1 1
2 1 1 2
3 3 2 3
4 1 1 2
4 2 1 2
Output
13
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i,n) for(int (i)=0;(i)<(int)(n);++(i))
#define all(x) (x).begin(),(x).end()
#define pb push_back
#define fi first
#define se second
#define dbg(x) cout<<#x" = "<<((x))<<endl
template<class T,class U> ostream& operator<<(ostream& o, const pair<T,U> &p){o<<"("<<p.fi<<","<<p.se<<")";return o;}
template<class T> ostream& operator<<(ostream& o, const vector<T> &v){o<<"[";for(T t:v){o<<t<<",";}o<<"]";return o;}
// i????????????????????????,j????§????????????£???
int dp[50][50]={};
int main()
{
int n,m,l;
cin >>n >>m >>l;
vector<int> s(m),g(m),w(m);
rep(i,m)
{
int d,a,k;
cin >>d >>a >>k >>w[i];
s[i] = d*n+a-1;
g[i] = s[i]+k;
}
rep(i,5*n)rep(j,l)rep(k,m)
{
if(i<=s[k]) dp[g[k]][j+1] = max(dp[g[k]][j+1], dp[i][j]+w[k]);
}
int ans = 0;
rep(i,50)rep(j,l+1) ans = max(ans,dp[i][j]);
cout << ans << endl;
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
There are n sharks who grow flowers for Wet Shark. They are all sitting around the table, such that sharks i and i + 1 are neighbours for all i from 1 to n - 1. Sharks n and 1 are neighbours too.
Each shark will grow some number of flowers si. For i-th shark value si is random integer equiprobably chosen in range from li to ri. Wet Shark has it's favourite prime number p, and he really likes it! If for any pair of neighbouring sharks i and j the product si·sj is divisible by p, then Wet Shark becomes happy and gives 1000 dollars to each of these sharks.
At the end of the day sharks sum all the money Wet Shark granted to them. Find the expectation of this value.
Input
The first line of the input contains two space-separated integers n and p (3 ≤ n ≤ 100 000, 2 ≤ p ≤ 109) — the number of sharks and Wet Shark's favourite prime number. It is guaranteed that p is prime.
The i-th of the following n lines contains information about i-th shark — two space-separated integers li and ri (1 ≤ li ≤ ri ≤ 109), the range of flowers shark i can produce. Remember that si is chosen equiprobably among all integers from li to ri, inclusive.
Output
Print a single real number — the expected number of dollars that the sharks receive in total. You answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct, if <image>.
Examples
Input
3 2
1 2
420 421
420420 420421
Output
4500.0
Input
3 5
1 4
2 3
11 14
Output
0.0
Note
A prime number is a positive integer number that is divisible only by 1 and itself. 1 is not considered to be prime.
Consider the first sample. First shark grows some number of flowers from 1 to 2, second sharks grows from 420 to 421 flowers and third from 420420 to 420421. There are eight cases for the quantities of flowers (s0, s1, s2) each shark grows:
1. (1, 420, 420420): note that s0·s1 = 420, s1·s2 = 176576400, and s2·s0 = 420420. For each pair, 1000 dollars will be awarded to each shark. Therefore, each shark will be awarded 2000 dollars, for a total of 6000 dollars.
2. (1, 420, 420421): now, the product s2·s0 is not divisible by 2. Therefore, sharks s0 and s2 will receive 1000 dollars, while shark s1 will receive 2000. The total is 4000.
3. (1, 421, 420420): total is 4000
4. (1, 421, 420421): total is 0.
5. (2, 420, 420420): total is 6000.
6. (2, 420, 420421): total is 6000.
7. (2, 421, 420420): total is 6000.
8. (2, 421, 420421): total is 4000.
The expected value is <image>.
In the second sample, no combination of quantities will garner the sharks any money.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > vec;
double func(pair<int, int> x, pair<int, int> y, int p) {
long long total =
(long long)(x.second - x.first + 1) * (long long)(y.second - y.first + 1);
long long fav = 0;
long long divU = x.second / p;
long long divL = (x.first - 1) / p;
fav = (divU - divL) * (long long)(y.second - y.first + 1);
long long rem = (long long)(x.second - x.first + 1) - (divU - divL);
divU = y.second / p;
divL = (y.first - 1) / p;
long long fav2 = (divU - divL) * (long long)rem;
double inFav = fav + fav2;
return (2000.0 * inFav) / (double)total;
}
int main() {
int n, p;
scanf("%d %d", &n, &p);
for (int i = 0, l, r; i < n; i++) {
scanf("%d %d", &l, &r);
vec.push_back(make_pair(l, r));
}
vec.push_back(*vec.begin());
double ans = 0;
for (int i = 0; i < n; i++) ans += func(vec[i], vec[i + 1], p);
printf("%.10lf\n", ans);
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Vasya is reading a e-book. The file of the book consists of n pages, numbered from 1 to n. The screen is currently displaying the contents of page x, and Vasya wants to read the page y. There are two buttons on the book which allow Vasya to scroll d pages forwards or backwards (but he cannot scroll outside the book). For example, if the book consists of 10 pages, and d = 3, then from the first page Vasya can scroll to the first or to the fourth page by pressing one of the buttons; from the second page — to the first or to the fifth; from the sixth page — to the third or to the ninth; from the eighth — to the fifth or to the tenth.
Help Vasya to calculate the minimum number of times he needs to press a button to move to page y.
Input
The first line contains one integer t (1 ≤ t ≤ 10^3) — the number of testcases.
Each testcase is denoted by a line containing four integers n, x, y, d (1≤ n, d ≤ 10^9, 1 ≤ x, y ≤ n) — the number of pages, the starting page, the desired page, and the number of pages scrolled by pressing one button, respectively.
Output
Print one line for each test.
If Vasya can move from page x to page y, print the minimum number of times he needs to press a button to do it. Otherwise print -1.
Example
Input
3
10 4 5 2
5 1 3 4
20 4 19 3
Output
4
-1
5
Note
In the first test case the optimal sequence is: 4 → 2 → 1 → 3 → 5.
In the second test case it is possible to get to pages 1 and 5.
In the third test case the optimal sequence is: 4 → 7 → 10 → 13 → 16 → 19.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
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 m, x, y, n;
long long abss(long long a) { return a >= 0 ? a : -a; }
long long minn(long long a, long long b) { return a > b ? b : a; }
int main() {
long long T = Read(), ans;
for (int i = 1; i <= T; i++) {
m = Read(), x = Read(), y = Read(), n = Read();
ans = 1e9 + 7;
if (abss(x - y) % n == 0) {
cout << abss(x - y) / n << endl;
ans = 0;
} else {
if (abss(1 - y) % n == 0)
ans = (abss(x - 1) + n - 1) / n + abss(y - 1) / n;
if (abss(m - y) % n == 0)
ans = minn(ans, (abss(m - x) + n - 1) / n + abss(y - m) / n);
if (ans == 1e9 + 7)
cout << "-1" << endl;
else
cout << ans << endl;
}
}
return 0;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
Ali is Hamed's little brother and tomorrow is his birthday. Hamed wants his brother to earn his gift so he gave him a hard programming problem and told him if he can successfully solve it, he'll get him a brand new laptop. Ali is not yet a very talented programmer like Hamed and although he usually doesn't cheat but this time is an exception. It's about a brand new laptop. So he decided to secretly seek help from you. Please solve this problem for Ali.
An n-vertex weighted rooted tree is given. Vertex number 1 is a root of the tree. We define d(u, v) as the sum of edges weights on the shortest path between vertices u and v. Specifically we define d(u, u) = 0. Also let's define S(v) for each vertex v as a set containing all vertices u such that d(1, u) = d(1, v) + d(v, u). Function f(u, v) is then defined using the following formula:
<image>
The goal is to calculate f(u, v) for each of the q given pair of vertices. As the answer can be rather large it's enough to print it modulo 109 + 7.
Input
In the first line of input an integer n (1 ≤ n ≤ 105), number of vertices of the tree is given.
In each of the next n - 1 lines three space-separated integers ai, bi, ci (1 ≤ ai, bi ≤ n, 1 ≤ ci ≤ 109) are given indicating an edge between ai and bi with weight equal to ci.
In the next line an integer q (1 ≤ q ≤ 105), number of vertex pairs, is given.
In each of the next q lines two space-separated integers ui, vi (1 ≤ ui, vi ≤ n) are given meaning that you must calculate f(ui, vi).
It is guaranteed that the given edges form a tree.
Output
Output q lines. In the i-th line print the value of f(ui, vi) modulo 109 + 7.
Examples
Input
5
1 2 1
4 3 1
3 5 1
1 3 1
5
1 1
1 5
2 4
2 1
3 5
Output
10
1000000005
1000000002
23
1000000002
Input
8
1 2 100
1 3 20
2 4 2
2 5 1
3 6 1
3 7 2
6 8 5
6
1 8
2 3
5 8
2 6
4 7
6 1
Output
999968753
49796
999961271
999991235
999958569
45130
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 10, mod = 1e9 + 7, lg = 16 + 2;
long long n, q, par[N][lg], sumup[N][lg], tvin[N][lg], sumin[N][lg],
cntin[N][lg], sumst[N], tvst[N], cntst[N], updtv[N], updsum[N], updcnt[N],
h[N];
vector<pair<long long, long long> > gr[N];
long long mrg(long long ftv, long long fsum, long long fcnt, long long add) {
return 1ll *
(1ll * ftv + 1ll * fsum * add % mod * 2 % mod +
1ll * add * add % mod * fcnt % mod) %
mod;
}
void getSt(long long v, long long par = -1) {
for (auto p : gr[v]) {
long long u = p.first, w = p.second;
if (u != par) {
getSt(u, v);
updtv[u] = mrg(tvst[u], sumst[u], cntst[u], w),
tvst[v] = (tvst[v] + updtv[u]) % mod;
updsum[u] = (1ll * cntst[u] * w % mod + sumst[u]) % mod,
sumst[v] = (sumst[v] + updsum[u]) % mod;
updcnt[u] = cntst[u], cntst[v] = cntst[v] + updcnt[u];
}
}
cntst[v]++;
}
void getPr(long long v, long long parent = -1, long long wb = -1) {
if (parent != -1) {
h[v] = h[parent] + 1;
par[v][0] = parent, sumup[v][0] = wb;
for (long long i = 1; i < lg - 1; i++)
par[v][i] = par[par[v][i - 1]][i - 1],
sumup[v][i] = (sumup[v][i - 1] + sumup[par[v][i - 1]][i - 1]) % mod;
cntin[v][0] = cntst[parent] - updcnt[v],
sumin[v][0] = (sumst[parent] - updsum[v] + mod) % mod;
tvin[v][0] = mrg((tvst[parent] - updtv[v] + mod) % mod, sumin[v][0],
cntin[v][0], wb);
sumin[v][0] = (sumin[v][0] + 1ll * cntin[v][0] * wb % mod) % mod;
for (long long i = 1; i < lg - 1; i++) {
cntin[v][i] = (cntin[v][i - 1] + cntin[par[v][i - 1]][i - 1]) % mod;
sumin[v][i] = ((sumin[v][i - 1] + 1ll * sumup[v][i - 1] *
cntin[par[v][i - 1]][i - 1] % mod) %
mod +
sumin[par[v][i - 1]][i - 1] % mod) %
mod;
tvin[v][i] = (tvin[v][i - 1] +
mrg(tvin[par[v][i - 1]][i - 1], sumin[par[v][i - 1]][i - 1],
cntin[par[v][i - 1]][i - 1], sumup[v][i - 1])) %
mod;
}
}
for (auto p : gr[v]) {
long long u = p.first, w = p.second;
if (u != parent) getPr(u, v, w);
}
}
bool isAnc(long long v, long long u) {
long long diff = h[v] - h[u];
if (diff <= 0) return false;
for (long long i = 0; i < lg - 1; i++)
if (((diff >> i) & 1)) v = par[v][i];
if (v == u) return true;
return false;
}
long long AnsAnc(long long v, long long u) {
long long pst = tvst[v], rtr = 0, sumrn = 0;
long long diff = h[v] - h[u];
for (long long i = lg - 1; i >= 0; i--) {
if (((diff >> i) & 1)) {
rtr = (rtr + mrg(tvin[v][i], sumin[v][i], cntin[v][i], sumrn)) % mod;
sumrn = (sumrn + sumup[v][i]) % mod;
v = par[v][i];
}
}
return (rtr + pst) % mod;
}
long long getSum(long long v, long long u) {
if (h[u] > h[v]) swap(u, v);
long long diff = h[v] - h[u], rtr = 0;
for (long long i = 0; i < lg - 1; i++) {
if (((diff >> i) & 1)) rtr = (rtr + sumup[v][i]) % mod, v = par[v][i];
}
if (v == u) return rtr;
for (long long i = lg - 1; i >= 0; i--) {
if (par[v][i] != par[u][i]) {
rtr = ((rtr + sumup[v][i]) % mod + sumup[u][i]) % mod;
v = par[v][i], u = par[u][i];
}
}
rtr = ((rtr + sumup[v][0]) % mod + sumup[u][0]) % mod;
return rtr;
}
long long AnsN(long long v, long long u) {
long long sum = getSum(v, u);
return mrg(tvst[u], sumst[u], cntst[u], sum);
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (long long i = 0; i < n - 1; i++) {
long long x, y, w;
cin >> x >> y >> w;
x--, y--;
gr[x].push_back({y, w});
gr[y].push_back({x, w});
}
getSt(0);
getPr(0);
cin >> q;
while (q--) {
long long x, y;
cin >> x >> y;
x--, y--;
long long rtr;
if (isAnc(x, y))
rtr = AnsAnc(x, y);
else
rtr = AnsN(x, y);
long long mn = AnsAnc(x, 0);
rtr = ((rtr * 2 - mn) % mod + mod) % mod;
cout << rtr << "\n";
}
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
Each New Year Timofey and his friends cut down a tree of n vertices and bring it home. After that they paint all the n its vertices, so that the i-th vertex gets color ci.
Now it's time for Timofey birthday, and his mother asked him to remove the tree. Timofey removes the tree in the following way: he takes some vertex in hands, while all the other vertices move down so that the tree becomes rooted at the chosen vertex. After that Timofey brings the tree to a trash can.
Timofey doesn't like it when many colors are mixing together. A subtree annoys him if there are vertices of different color in it. Timofey wants to find a vertex which he should take in hands so that there are no subtrees that annoy him. He doesn't consider the whole tree as a subtree since he can't see the color of the root vertex.
A subtree of some vertex is a subgraph containing that vertex and all its descendants.
Your task is to determine if there is a vertex, taking which in hands Timofey wouldn't be annoyed.
Input
The first line contains single integer n (2 ≤ n ≤ 105) — the number of vertices in the tree.
Each of the next n - 1 lines contains two integers u and v (1 ≤ u, v ≤ n, u ≠ v), denoting there is an edge between vertices u and v. It is guaranteed that the given graph is a tree.
The next line contains n integers c1, c2, ..., cn (1 ≤ ci ≤ 105), denoting the colors of the vertices.
Output
Print "NO" in a single line, if Timofey can't take the tree in such a way that it doesn't annoy him.
Otherwise print "YES" in the first line. In the second line print the index of the vertex which Timofey should take in hands. If there are multiple answers, print any of them.
Examples
Input
4
1 2
2 3
3 4
1 2 1 1
Output
YES
2
Input
3
1 2
2 3
1 2 3
Output
YES
2
Input
4
1 2
2 3
3 4
1 2 1 2
Output
NO
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int common(pair<int, int> a, pair<int, int> b) {
if (a.first == b.first || a.first == b.second) return a.first;
if (a.second == b.first || a.second == b.second) return a.second;
return -1;
}
int main() {
int n;
cin >> n;
vector<pair<int, int> > data(n - 1);
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
data[i] = make_pair(a, b);
}
int col[n];
for (int i = 0; i < n; i++) cin >> col[i];
pair<int, int> p1, p2;
int status = 0;
int cand;
for (int i = 0; i < n - 1; i++) {
if (col[data[i].first] != col[data[i].second]) {
if (status == 0) {
p1 = data[i];
status = 1;
} else if (status == 1) {
p2 = data[i];
status = 2;
cand = common(p1, p2);
if (cand == -1) {
cout << "NO" << endl;
return 0;
}
} else {
if (data[i].first != cand && data[i].second != cand) {
cout << "NO" << endl;
return 0;
}
}
}
}
cout << "YES" << endl;
if (status == 0)
cout << "1" << endl;
else if (status == 1)
cout << p1.first + 1 << endl;
else
cout << cand + 1 << endl;
return 0;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
You are given n segments on a coordinate line; each endpoint of every segment has integer coordinates. Some segments can degenerate to points. Segments can intersect with each other, be nested in each other or even coincide.
Your task is the following: for every k ∈ [1..n], calculate the number of points with integer coordinates such that the number of segments that cover these points equals k. A segment with endpoints l_i and r_i covers point x if and only if l_i ≤ x ≤ r_i.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of segments.
The next n lines contain segments. The i-th line contains a pair of integers l_i, r_i (0 ≤ l_i ≤ r_i ≤ 10^{18}) — the endpoints of the i-th segment.
Output
Print n space separated integers cnt_1, cnt_2, ..., cnt_n, where cnt_i is equal to the number of points such that the number of segments that cover these points equals to i.
Examples
Input
3
0 3
1 3
3 8
Output
6 2 1
Input
3
1 3
2 4
5 7
Output
5 2 0
Note
The picture describing the first example:
<image>
Points with coordinates [0, 4, 5, 6, 7, 8] are covered by one segment, points [1, 2] are covered by two segments and point [3] is covered by three segments.
The picture describing the second example:
<image>
Points [1, 4, 5, 6, 7] are covered by one segment, points [2, 3] are covered by two segments and there are no points covered by three segments.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3f;
long long tot[200010];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vector<pair<long long, int> > v;
for (int i = 0; i < n; i++) {
long long l, r;
cin >> l >> r;
v.push_back({l, -1});
v.push_back({r + 1, 1});
}
sort(v.begin(), v.end());
long long open = 0;
long long last = v[0].first;
for (int i = 0; i < v.size();) {
long long pos = v[i].first;
tot[open] += pos - last;
while (i < v.size() && v[i].first == pos) {
open -= v[i].second;
i++;
}
last = pos;
}
for (int i = 1; i <= n; i++) cout << tot[i] << " ";
cout << '\n';
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
There are n servers in a laboratory, each of them can perform tasks. Each server has a unique id — integer from 1 to n.
It is known that during the day q tasks will come, the i-th of them is characterized with three integers: ti — the moment in seconds in which the task will come, ki — the number of servers needed to perform it, and di — the time needed to perform this task in seconds. All ti are distinct.
To perform the i-th task you need ki servers which are unoccupied in the second ti. After the servers begin to perform the task, each of them will be busy over the next di seconds. Thus, they will be busy in seconds ti, ti + 1, ..., ti + di - 1. For performing the task, ki servers with the smallest ids will be chosen from all the unoccupied servers. If in the second ti there are not enough unoccupied servers, the task is ignored.
Write the program that determines which tasks will be performed and which will be ignored.
Input
The first line contains two positive integers n and q (1 ≤ n ≤ 100, 1 ≤ q ≤ 105) — the number of servers and the number of tasks.
Next q lines contains three integers each, the i-th line contains integers ti, ki and di (1 ≤ ti ≤ 106, 1 ≤ ki ≤ n, 1 ≤ di ≤ 1000) — the moment in seconds in which the i-th task will come, the number of servers needed to perform it, and the time needed to perform this task in seconds. The tasks are given in a chronological order and they will come in distinct seconds.
Output
Print q lines. If the i-th task will be performed by the servers, print in the i-th line the sum of servers' ids on which this task will be performed. Otherwise, print -1.
Examples
Input
4 3
1 3 2
2 2 1
3 4 3
Output
6
-1
10
Input
3 2
3 2 3
5 1 2
Output
3
3
Input
8 6
1 3 20
4 2 1
6 5 5
10 1 1
15 3 6
21 8 8
Output
6
9
30
-1
15
36
Note
In the first example in the second 1 the first task will come, it will be performed on the servers with ids 1, 2 and 3 (the sum of the ids equals 6) during two seconds. In the second 2 the second task will come, it will be ignored, because only the server 4 will be unoccupied at that second. In the second 3 the third task will come. By this time, servers with the ids 1, 2 and 3 will be unoccupied again, so the third task will be done on all the servers with the ids 1, 2, 3 and 4 (the sum of the ids is 10).
In the second example in the second 3 the first task will come, it will be performed on the servers with ids 1 and 2 (the sum of the ids is 3) during three seconds. In the second 5 the second task will come, it will be performed on the server 3, because the first two servers will be busy performing the first task.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, q;
cin >> n >> q;
int arr[n + 1], indic[n + 1];
memset(arr, -1, sizeof(arr));
for (int x = 0; x < q; x++) {
int t, k, d;
cin >> t >> k >> d;
int count = 0, sum = 0, p;
bool cond = false;
for (int i = 1; i <= n; i++) {
if (count == k) {
cond = true;
break;
}
if (arr[i] == -1 || arr[i] <= t) {
arr[i] = t + d;
sum += i;
indic[i] = x;
count++;
p = i;
}
}
if (count == k) cond = true;
if (!cond) {
for (int i = 1; i <= n; i++) {
if (indic[i] == x) {
arr[i] = -1;
indic[i] = -1;
}
}
cout << -1 << endl;
}
if (cond) cout << sum << endl;
}
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
Vasya has a pile, that consists of some number of stones. n times he either took one stone from the pile or added one stone to the pile. The pile was non-empty before each operation of taking one stone from the pile.
You are given n operations which Vasya has made. Find the minimal possible number of stones that can be in the pile after making these operations.
Input
The first line contains one positive integer n — the number of operations, that have been made by Vasya (1 ≤ n ≤ 100).
The next line contains the string s, consisting of n symbols, equal to "-" (without quotes) or "+" (without quotes). If Vasya took the stone on i-th operation, s_i is equal to "-" (without quotes), if added, s_i is equal to "+" (without quotes).
Output
Print one integer — the minimal possible number of stones that can be in the pile after these n operations.
Examples
Input
3
---
Output
0
Input
4
++++
Output
4
Input
2
-+
Output
1
Input
5
++-++
Output
3
Note
In the first test, if Vasya had 3 stones in the pile at the beginning, after making operations the number of stones will be equal to 0. It is impossible to have less number of piles, so the answer is 0. Please notice, that the number of stones at the beginning can't be less, than 3, because in this case, Vasya won't be able to take a stone on some operation (the pile will be empty).
In the second test, if Vasya had 0 stones in the pile at the beginning, after making operations the number of stones will be equal to 4. It is impossible to have less number of piles because after making 4 operations the number of stones in the pile increases on 4 stones. So, the answer is 4.
In the third test, if Vasya had 1 stone in the pile at the beginning, after making operations the number of stones will be equal to 1. It can be proved, that it is impossible to have less number of stones after making the operations.
In the fourth test, if Vasya had 0 stones in the pile at the beginning, after making operations the number of stones will be equal to 3.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(void) {
ios::sync_with_stdio(false);
int n;
char s[105];
cin >> n >> s;
int ans = 0, cnt;
for (int i = 0; i < n; ++i) {
if (s[i] == '-')
cnt = -1;
else
cnt = 1;
ans += cnt;
if (ans < 0) ans = 0;
}
cout << ans << '\n';
return 0;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
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>
using namespace std;
const int nmax = 200009;
int a[nmax], b[nmax], c[nmax], sum, i, n, used[nmax], bp[nmax], cp[nmax], j,
flag;
long long st;
int main() {
scanf("%d", &n);
for (i = 1; i <= n; ++i) {
scanf("%d", &b[i]);
st += b[i];
}
for (i = 1; i <= n; ++i) {
scanf("%d", &c[i]);
st += c[i];
}
if (st % (n + n) == 0)
sum = st / (n + n);
else {
printf("-1\n");
return 0;
}
for (i = 1; i <= n; ++i) {
if ((b[i] + c[i] - sum) % n) {
printf("-1\n");
return 0;
}
a[i] = (b[i] + c[i] - sum) / n;
}
for (i = 1; i <= n; ++i) {
for (j = 0; j <= 30; ++j)
if (a[i] & (1 << j)) used[j]++;
}
for (i = 1; i <= n; ++i) {
for (j = 0; j <= 30; ++j)
if (a[i] & (1 << j)) {
bp[i] += (1 << j) * used[j];
cp[i] += n * (1 << j);
} else
cp[i] += (1 << j) * used[j];
}
flag = 1;
for (i = 1; i <= n; ++i) flag &= (bp[i] == b[i] && cp[i] == c[i]);
if (flag) {
for (i = 1; i <= n; ++i) printf("%d\n", a[i]);
} else
printf("-1\n");
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
Bessie the cow and her best friend Elsie each received a sliding puzzle on Pi Day. Their puzzles consist of a 2 × 2 grid and three tiles labeled 'A', 'B', and 'C'. The three tiles sit on top of the grid, leaving one grid cell empty. To make a move, Bessie or Elsie can slide a tile adjacent to the empty cell into the empty cell as shown below:
<image>
In order to determine if they are truly Best Friends For Life (BFFLs), Bessie and Elsie would like to know if there exists a sequence of moves that takes their puzzles to the same configuration (moves can be performed in both puzzles). Two puzzles are considered to be in the same configuration if each tile is on top of the same grid cell in both puzzles. Since the tiles are labeled with letters, rotations and reflections are not allowed.
Input
The first two lines of the input consist of a 2 × 2 grid describing the initial configuration of Bessie's puzzle. The next two lines contain a 2 × 2 grid describing the initial configuration of Elsie's puzzle. The positions of the tiles are labeled 'A', 'B', and 'C', while the empty cell is labeled 'X'. It's guaranteed that both puzzles contain exactly one tile with each letter and exactly one empty position.
Output
Output "YES"(without quotes) if the puzzles can reach the same configuration (and Bessie and Elsie are truly BFFLs). Otherwise, print "NO" (without quotes).
Examples
Input
AB
XC
XB
AC
Output
YES
Input
AB
XC
AC
BX
Output
NO
Note
The solution to the first sample is described by the image. All Bessie needs to do is slide her 'A' tile down.
In the second sample, the two puzzles can never be in the same configuration. Perhaps Bessie and Elsie are not meant to be friends after all...
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18 + 9;
const long long mod = 1e9 + 7;
const long long maxn = 2e5 + 8;
char s[5][5], t[5][5];
long long n, m;
void solve() {
long long i, j;
cin >> s[1] + 1 >> s[2] + 1 >> t[1] + 1 >> t[2] + 1;
if (s[2][2] == 'X') swap(s[2][1], s[2][2]);
if (s[1][2] == 'X') swap(s[1][1], s[1][2]);
if (s[1][1] == 'X') swap(s[1][1], s[2][1]);
if (t[2][2] == 'X') swap(t[2][1], t[2][2]);
if (t[1][2] == 'X') swap(t[1][1], t[1][2]);
if (t[1][1] == 'X') swap(t[1][1], t[2][1]);
if (s[1][1] == t[1][1] && s[1][2] == t[1][2] && s[2][1] == t[2][1] &&
s[2][2] == t[2][2])
return (void)(cout << "YES" << endl);
swap(s[1][1], s[2][1]);
swap(s[1][1], s[1][2]);
swap(s[1][2], s[2][2]);
swap(s[2][1], s[2][2]);
if (s[1][1] == t[1][1] && s[1][2] == t[1][2] && s[2][1] == t[2][1] &&
s[2][2] == t[2][2])
return (void)(cout << "YES" << endl);
swap(s[1][1], s[2][1]);
swap(s[1][1], s[1][2]);
swap(s[1][2], s[2][2]);
swap(s[2][1], s[2][2]);
if (s[1][1] == t[1][1] && s[1][2] == t[1][2] && s[2][1] == t[2][1] &&
s[2][2] == t[2][2])
return (void)(cout << "YES" << endl);
swap(s[1][1], s[2][1]);
swap(s[1][1], s[1][2]);
swap(s[1][2], s[2][2]);
swap(s[2][1], s[2][2]);
if (s[1][1] == t[1][1] && s[1][2] == t[1][2] && s[2][1] == t[2][1] &&
s[2][2] == t[2][2])
return (void)(cout << "YES" << endl);
cout << "NO" << endl;
}
signed main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
long long t = 1;
while (t--) solve();
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
To celebrate the second ABBYY Cup tournament, the Smart Beaver decided to throw a party. The Beaver has a lot of acquaintances, some of them are friends with each other, and some of them dislike each other. To make party successful, the Smart Beaver wants to invite only those of his friends who are connected by friendship relations, and not to invite those who dislike each other. Both friendship and dislike are mutual feelings.
More formally, for each invited person the following conditions should be fulfilled:
* all his friends should also be invited to the party;
* the party shouldn't have any people he dislikes;
* all people who are invited to the party should be connected with him by friendship either directly or through a chain of common friends of arbitrary length. We'll say that people a1 and ap are connected through a chain of common friends if there exists a sequence of people a2, a3, ..., ap - 1 such that all pairs of people ai and ai + 1 (1 ≤ i < p) are friends.
Help the Beaver find the maximum number of acquaintances he can invite.
Input
The first line of input contains an integer n — the number of the Beaver's acquaintances.
The second line contains an integer k <image> — the number of pairs of friends. Next k lines contain space-separated pairs of integers ui, vi <image> — indices of people who form the i-th pair of friends.
The next line contains an integer m <image> — the number of pairs of people who dislike each other. Next m lines describe pairs of people who dislike each other in the same format as the pairs of friends were described.
Each pair of people is mentioned in the input at most once <image>. In particular, two persons cannot be friends and dislike each other at the same time.
The input limitations for getting 30 points are:
* 2 ≤ n ≤ 14
The input limitations for getting 100 points are:
* 2 ≤ n ≤ 2000
Output
Output a single number — the maximum number of people that can be invited to the party. If a group of people that meets all the requirements is impossible to select, output 0.
Examples
Input
9
8
1 2
1 3
2 3
4 5
6 7
7 8
8 9
9 6
2
1 6
7 9
Output
3
Note
Let's have a look at the example.
<image>
Two groups of people can be invited: {1, 2, 3} and {4, 5}, thus the answer will be the size of the largest of these groups. Group {6, 7, 8, 9} doesn't fit, since it includes people 7 and 9 who dislike each other. Group {1, 2, 3, 4, 5} also doesn't fit, because not all of its members are connected by a chain of common friends (for example, people 2 and 5 aren't connected).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 7;
vector<int> adj[MAX];
bool mark[MAX], group[MAX];
int gr[MAX], fr[MAX];
void dfs(int u, int groupID);
int n, k, m;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (int i = 1; i <= k; ++i) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
int groupID = 1;
for (int i = 1; i <= n; ++i) {
if (!mark[i]) {
dfs(i, groupID);
group[groupID] = true;
++groupID;
}
}
cin >> m;
for (int i = 1; i <= m; ++i) {
int u, v;
cin >> u >> v;
if (gr[u] == gr[v]) {
group[gr[u]] = false;
}
}
memset(fr, 0, sizeof(fr));
int res = 0;
for (int i = 1; i <= n; ++i) {
fr[gr[i]]++;
}
for (int i = 1; i <= n; ++i) {
if (group[i]) {
res = max(res, fr[i]);
}
}
cout << res << "\n";
return 0;
}
void dfs(int u, int groupID) {
gr[u] = groupID;
mark[u] = true;
int size = adj[u].size();
for (int i = 0; i < size; ++i) {
if (!mark[adj[u][i]]) {
dfs(adj[u][i], groupID);
}
}
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
You are given a set $T$, which is a subset of $U$. The set $U$ consists of $0, 1, ... n-1$. Print all sets, each of which is a subset of $U$ and includes $T$ as a subset. Note that we represent $0, 1, ... n-1$ as 00...0001, 00...0010, 00...0100, ..., 10...0000 in binary respectively and the integer representation of a subset is calculated by bitwise OR of existing elements.
Constraints
* $1 \leq n \leq 18$
* $0 \leq k \leq n$
* $0 \leq b_i < n$
Input
The input is given in the following format.
$n$
$k \; b_0 \; b_1 \; ... \; b_{k-1}$
$k$ is the number of elements in $T$, and $b_i$ represents elements in $T$.
Output
Print the subsets ordered by their decimal integers. Print a subset in the following format.
$d$: $e_0$ $e_1$ ...
Print ':' after the integer value $d$, then print elements $e_i$ in the subset in ascending order. Separate two adjacency elements by a space character.
Example
Input
4
2 0 2
Output
5: 0 2
7: 0 1 2
13: 0 2 3
15: 0 1 2 3
### Response
```cpp
#include <cstdio>
#include <utility>
#include <vector>
#include <algorithm>
using namespace std;
#define gcu getchar_unlocked
#define pcu putchar_unlocked
#define _T template <typename T>
#define _HT template <typename H, typename... T>
#define _il inline
#define _in _il int in
#define _sc _il bool scan
_T T in(int c){T n=0;bool m=false;if(c=='-')m=true,c=gcu();
do{n=10*n+(c-'0'),c=gcu();}while(c>='0');return m?-n:n;} //&&c<='9'
_in() {return in<int>(gcu());}
_T T scan(T &n){int c=gcu();return c==EOF?false:(n=in<T>(c),true);}
_sc(char &c){c=gcu();gcu();return c!=EOF;}
#ifdef _GLIBCXX_STRING
_sc(string &s){int c;s="";
for(;;){c=gcu();if(c=='\n'||c==' ')return true;else if(c==EOF)return false;s+=c;}}
#endif
_HT _sc(H &h, T&&... t){return scan(h)&&scan(t...);}
#define _vo _il void out
#define _vl _il void outl
_vo(const char *s){while(*s)pcu(*s++);}
_vo(char c){pcu(c);}
#ifdef _GLIBCXX_STRING
_vo(string s){for(char c:s)pcu(c);}
#endif
_T _vo(T n){static char buf[20];char *p=buf;
if(n<0)pcu('-'),n*=-1;if(!n)*p++='0';else while(n)*p++=n%10+'0',n/=10;
while (p!=buf)pcu(*--p);}
_vl(){out('\n');}
#ifdef _GLIBCXX_VECTOR
_T _vo(vector<T> &v){for(T &x:v)out(&x == &v[0]?"":" "),out(x);outl();}
#endif
_HT _vo(H&& h, T&&... t){out(h);out(move(t)...);}
template <typename... T> _vl(T&&... t){out(move(t)...);outl();}
void dump(int n) {
out(n, ':');
for (int j = 0, t; (t = n >> j); j++)
if (t & 1)
out(' ', j);
outl();
}
typedef vector<int> v;
void enumeration(int t, int i, int n, v &r) {
if (i >= n) {
r.push_back(t);
return;
}
if ((t >> i) & 1)
enumeration(t, i + 1, n, r);
else {
enumeration(t, i + 1, n, r);
enumeration((1 << i) | t, i + 1, n, r);
}
}
int main() {
int n = in(), u = 0;
v r;
for (int i = in(); i; i--)
u |= 1 << in();
enumeration(u, 0, n, r);
sort(r.begin(), r.end());
for (int x: r)
dump(x);
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
An old document says that a Ninja House in Kanazawa City was in fact a defensive fortress, which was designed like a maze. Its rooms were connected by hidden doors in a complicated manner, so that any invader would become lost. Each room has at least two doors.
The Ninja House can be modeled by a graph, as shown in Figure l. A circle represents a room. Each line connecting two circles represents a door between two rooms.
<image> Figure l. Graph Model of Ninja House. | Figure 2. Ninja House exploration.
---|---
I decided to draw a map, since no map was available. Your mission is to help me draw a map from the record of my exploration.
I started exploring by entering a single entrance that was open to the outside. The path I walked is schematically shown in Figure 2, by a line with arrows. The rules for moving between rooms are described below.
After entering a room, I first open the rightmost door and move to the next room. However, if the next room has already been visited, I close the door without entering, and open the next rightmost door, and so on. When I have inspected all the doors of a room, I go back through the door I used to enter the room.
I have a counter with me to memorize the distance from the first room. The counter is incremented when I enter a new room, and decremented when I go back from a room. In Figure 2, each number in parentheses is the value of the counter when I have entered the room, i.e., the distance from the first room. In contrast, the numbers not in parentheses represent the order of my visit.
I take a record of my exploration. Every time I open a door, I record a single number, according to the following rules.
1. If the opposite side of the door is a new room, I record the number of doors in that room, which is a positive number.
2. If it is an already visited room, say R, I record ``the distance of R from the first room'' minus ``the distance of the current room from the first room'', which is a negative number.
In the example shown in Figure 2, as the first room has three doors connecting other rooms, I initially record ``3''. Then when I move to the second, third, and fourth rooms, which all have three doors, I append ``3 3 3'' to the record. When I skip the entry from the fourth room to the first room, the distance difference ``-3'' (minus three) will be appended, and so on. So, when I finish this exploration, its record is a sequence of numbers ``3 3 3 3 -3 3 2 -5 3 2 -5 -3''.
There are several dozens of Ninja Houses in the city. Given a sequence of numbers for each of these houses, you should produce a graph for each house.
Input
The first line of the input is a single integer n, indicating the number of records of Ninja Houses I have visited. You can assume that n is less than 100. Each of the following n records consists of numbers recorded on one exploration and a zero as a terminator. Each record consists of one or more lines whose lengths are less than 1000 characters. Each number is delimited by a space or a newline. You can assume that the number of rooms for each Ninja House is less than 100, and the number of doors in each room is less than 40.
Output
For each Ninja House of m rooms, the output should consist of m lines. The j-th line of each such m lines should look as follows:
i r1 r2 ... rki
where r1, ... , rki should be rooms adjoining room i, and ki should be the number of doors in room i. Numbers should be separated by exactly one space character. The rooms should be numbered from 1 in visited order. r1, r2, ... , rki should be in ascending order. Note that the room i may be connected to another room through more than one door. In this case, that room number should appear in r1, ... , rki as many times as it is connected by different doors.
Example
Input
2
3 3 3 3 -3 3 2 -5 3 2 -5 -3 0
3 5 4 -2 4 -3 -2 -2 -1 0
Output
1 2 4 6
2 1 3 8
3 2 4 7
4 1 3 5
5 4 6 7
6 1 5
7 3 5 8
8 2 7
1 2 3 4
2 1 3 3 4 4
3 1 2 2 4
4 1 2 2 3
### Response
```cpp
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <sstream>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <numeric>
#include <cctype>
#include <tuple>
#include <array>
#include <climits>
#include <bitset>
#include <cassert>
#include <ctime>
#include <list>
#ifdef _MSC_VER
#include <agents.h>
#endif
#define FOR(i, a, b) for(int i = (a); i < (int)(b); ++i)
#define rep(i, n) FOR(i, 0, n)
#define ALL(v) v.begin(), v.end()
#define REV(v) v.rbegin(), v.rend()
#define MEMSET(v, s) memset(v, s, sizeof(v))
#define UNIQUE(v) (v).erase(unique(ALL(v)), (v).end())
#define MP make_pair
#define MT make_tuple
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> P;
int num[110];
int vacant[110];
vector<vector<int>> G;
void add_edge(int a, int b){
G[a].push_back(b);
G[b].push_back(a);
}
vector<int> rec;
void dfs(int &id, int d, int prv, int &i){
if (rec.size() == i) return;
int cur = id;
int x = rec[i];
if (x < 0){
--id;
add_edge(prv, vacant[d - 1 + x]);
return;
}
if (prv > 0) add_edge(prv, cur);
num[cur] = x;
if (G[cur].size() < num[cur]) vacant[d] = cur;
while (G[cur].size() < num[cur]){
++id, ++i;
dfs(id, d + 1, cur, i);
}
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int t;
cin >> t;
while (t--){
rec.clear();
int a;
while (cin >> a, a) rec.push_back(a);
G.assign(110, vector<int>());
int id = 1, i = 0;
dfs(id, 0, -1, i);
for (int i = 1; i <= id; ++i){
sort(ALL(G[i]));
cout << i;
for (auto v : G[i]) cout << ' ' << v;
cout << endl;
}
}
return 0;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
Takahashi and Snuke came up with a game that uses a number sequence, as follows:
* Prepare a sequence of length M consisting of integers between 0 and 2^N-1 (inclusive): a = a_1, a_2, \ldots, a_M.
* Snuke first does the operation below as many times as he likes:
* Choose a positive integer d, and for each i (1 \leq i \leq M), in binary, set the d-th least significant bit of a_i to 0. (Here the least significant bit is considered the 1-st least significant bit.)
* After Snuke finishes doing operations, Takahashi tries to sort a in ascending order by doing the operation below some number of times. Here a is said to be in ascending order when a_i \leq a_{i + 1} for all i (1 \leq i \leq M - 1).
* Choose two adjacent elements of a: a_i and a_{i + 1}. If, in binary, these numbers differ in exactly one bit, swap a_i and a_{i + 1}.
There are 2^{NM} different sequences of length M consisting of integers between 0 and 2^N-1 that can be used in the game.
How many among them have the following property: if used in the game, there is always a way for Takahashi to sort the sequence in ascending order regardless of Snuke's operations? Find the count modulo (10^9 + 7).
Constraints
* All values in input are integers.
* 1 \leq N \leq 5000
* 2 \leq M \leq 5000
Input
Input is given from Standard Input in the following format:
N M
Output
Print the number, modulo (10^9 + 7), of sequences with the property: if used in the game, there is always a way for Takahashi to sort the sequence in ascending order regardless of Snuke's operations.
Examples
Input
2 5
Output
352
Input
2020 530
Output
823277409
### Response
```cpp
//Awwawa! Dis cold yis ratten buy tEMMIE!
#include <bits/stdc++.h>
#define ll long long
#define maxn 5005 /*rem*/
#define mod 1000000007
#define db double
#define vi vector<int>
#define pb push_back
#define mp make_pair
#define pi pair<int, int>
#define fi first
#define se second
template <typename T> bool chkmax(T &x,T y){return x<y?x=y,true:false;}
template <typename T> bool chkmin(T &x,T y){return x>y?x=y,true:false;}
using namespace std;
ll ksm(ll a, ll b) {
if (!b) return 1;
ll ns = ksm(a, b >> 1);
ns = ns * ns % mod;
if (b & 1) ns = ns * a % mod;
return ns;
}
ll pw[maxn];
ll dp[maxn][maxn];
int main() {
pw[0] = 1;
for (int i = 1; i < maxn; i++)
pw[i] = pw[i - 1] * 2 % mod;
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
ll pl = 0;
for (int j = 1; j <= m; j++) {
if (i == 1) dp[i][j] = pw[j];
else {
dp[i][j] = (j + 1) * dp[i - 1][j] % mod;
pl *= 2;
pl += dp[i - 1][j - 1] * (j - 1);
pl %= mod;
dp[i][j] = (dp[i][j] + pl) % mod;
// }
/*
dp[i][j] += dp[i - 1][j - d] * pw[d - 1] % mod * (j - d),
dp[i][j] %= mod;
*/
}
}
}
cout << dp[n][m] << endl;
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
An African crossword is a rectangular table n × m in size. Each cell of the table contains exactly one letter. This table (it is also referred to as grid) contains some encrypted word that needs to be decoded.
To solve the crossword you should cross out all repeated letters in rows and columns. In other words, a letter should only be crossed out if and only if the corresponding column or row contains at least one more letter that is exactly the same. Besides, all such letters are crossed out simultaneously.
When all repeated letters have been crossed out, we should write the remaining letters in a string. The letters that occupy a higher position follow before the letters that occupy a lower position. If the letters are located in one row, then the letter to the left goes first. The resulting word is the answer to the problem.
You are suggested to solve an African crossword and print the word encrypted there.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 100). Next n lines contain m lowercase Latin letters each. That is the crossword grid.
Output
Print the encrypted word on a single line. It is guaranteed that the answer consists of at least one letter.
Examples
Input
3 3
cba
bcd
cbc
Output
abcd
Input
5 5
fcofd
ooedo
afaoa
rdcdf
eofsf
Output
codeforces
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int m, n;
char a[105][105], b[105][105], c[105][105];
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%s", a[i]);
strcpy(b[i], a[i]);
strcpy(c[i], a[i]);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int flag = 0;
int k;
for (k = j + 1; k < m; k++) {
if (a[i][j] == a[i][k]) {
a[i][k] = '0';
flag = 1;
}
}
if (flag == 1) a[i][j] = '0';
}
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
int flag = 0;
int k;
for (k = j + 1; k < n; k++) {
if (b[j][i] == b[k][i]) {
b[k][i] = '0';
flag = 1;
}
}
if (flag == 1) b[j][i] = '0';
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i][j] == '0' || b[i][j] == '0') c[i][j] = '0';
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (c[i][j] != '0') printf("%c", c[i][j]);
}
}
printf("\n");
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
Vasily exited from a store and now he wants to recheck the total price of all purchases in his bill. The bill is a string in which the names of the purchases and their prices are printed in a row without any spaces. Check has the format "name1price1name2price2...namenpricen", where namei (name of the i-th purchase) is a non-empty string of length not more than 10, consisting of lowercase English letters, and pricei (the price of the i-th purchase) is a non-empty string, consisting of digits and dots (decimal points). It is possible that purchases with equal names have different prices.
The price of each purchase is written in the following format. If the price is an integer number of dollars then cents are not written.
Otherwise, after the number of dollars a dot (decimal point) is written followed by cents in a two-digit format (if number of cents is between 1 and 9 inclusively, there is a leading zero).
Also, every three digits (from less significant to the most) in dollars are separated by dot (decimal point). No extra leading zeroes are allowed. The price always starts with a digit and ends with a digit.
For example:
* "234", "1.544", "149.431.10", "0.99" and "123.05" are valid prices,
* ".333", "3.33.11", "12.00", ".33", "0.1234" and "1.2" are not valid.
Write a program that will find the total price of all purchases in the given bill.
Input
The only line of the input contains a non-empty string s with length not greater than 1000 — the content of the bill.
It is guaranteed that the bill meets the format described above. It is guaranteed that each price in the bill is not less than one cent and not greater than 106 dollars.
Output
Print the total price exactly in the same format as prices given in the input.
Examples
Input
chipsy48.32televizor12.390
Output
12.438.32
Input
a1b2c3.38
Output
6.38
Input
aa0.01t0.03
Output
0.04
### Response
```cpp
#include <bits/stdc++.h>
char a[1010];
int tot, cent;
int len;
int getnext(int pos) {
for (int i = pos + 1; i <= len; i++) {
if (a[i] == '.') return i;
if (!('0' <= a[i] && a[i] <= '9')) return 0;
}
return 0;
}
int main() {
scanf("%s", a + 1);
int i = 0, tmp = 0, next;
len = strlen(a + 1);
while (i <= len) {
if ('0' <= a[i + 1] && a[i + 1] <= '9') {
i++;
tmp = 0;
next = getnext(i);
if (next == 0) {
while ('0' <= a[i] && a[i] <= '9') {
tmp = tmp * 10 + a[i] - '0';
i++;
}
tot += tmp;
} else {
tmp = 0;
while (i < next) tmp = tmp * 10 + a[i] - '0', i++;
i++;
while (next && '0' <= a[next + 3] && a[next + 3] <= '9') {
i = next + 1;
while (i <= next + 3) {
tmp = tmp * 10 + a[i] - '0';
i++;
}
next = getnext(next);
}
if (!next)
tot += tmp;
else {
tot += tmp;
tmp = (a[next + 1] - '0') * 10 + a[next + 2] - '0';
cent += tmp;
i = next + 3;
}
}
} else
i++;
}
tot += (cent / 100);
cent %= 100;
bool st = 0;
if (tot / 1000 != 0) {
if (tot / 1000000 != 0) {
if (tot / 1000000000 != 0) {
printf("%d", tot / 1000000000);
tot %= 1000000000;
st = 1;
}
if (st)
printf(".%03d", tot / 1000000);
else
st = 1, printf("%d", tot / 1000000);
tot %= 1000000;
}
if (st)
printf(".%03d", tot / 1000);
else
st = 1, printf("%d", tot / 1000);
tot %= 1000;
}
if (st)
printf(".%03d", tot);
else
st = 1, printf("%d", tot);
if (cent != 0) printf(".%02d", cent);
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
You have n distinct points on a plane, none of them lie on OY axis. Check that there is a point after removal of which the remaining points are located on one side of the OY axis.
Input
The first line contains a single positive integer n (2 ≤ n ≤ 105).
The following n lines contain coordinates of the points. The i-th of these lines contains two single integers xi and yi (|xi|, |yi| ≤ 109, xi ≠ 0). No two points coincide.
Output
Print "Yes" if there is such a point, "No" — otherwise.
You can print every letter in any case (upper or lower).
Examples
Input
3
1 1
-1 -1
2 -1
Output
Yes
Input
4
1 1
2 2
-1 1
-2 2
Output
No
Input
3
1 2
2 1
4 60
Output
Yes
Note
In the first example the second point can be removed.
In the second example there is no suitable for the condition point.
In the third example any point can be removed.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
clock_t start;
mt19937_64 rng(chrono::system_clock::now().time_since_epoch().count());
template <typename T>
void _F(const char *name, T arg1) {
cerr << name << " = " << arg1 << '\n';
}
template <typename T, typename... Args>
void _F(const char *names, T arg1, Args... args) {
const char *name = strchr(names, ',');
cerr.write(names, name - names) << " = " << arg1 << '\n';
_F(name + 2, args...);
}
template <typename T1, typename T2>
istream &operator>>(istream &in, pair<T1, T2> &q) {
in >> q.first >> q.second;
return in;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &out, pair<T1, T2> &q) {
out << q.first << " " << q.second;
return out;
}
template <typename T1, typename T2>
pair<T1, T2> operator+(pair<T1, T2> p1, pair<T1, T2> p2) {
return {p1.first + p2.first, p1.second + p2.second};
}
template <typename T1, typename T2>
pair<T1, T2> operator-(pair<T1, T2> p1, pair<T1, T2> p2) {
return {p1.first - p2.first, p1.second - p2.second};
}
void solve() {
long long n;
cin >> n;
long long x, y, ne = 0, p = 0;
for (long long i = 0; i < n; i++) {
cin >> x >> y;
if (x < 0)
ne++;
else
p++;
}
if (ne <= 1 || p <= 1) {
cout << "YES" << '\n';
} else {
cout << "NO" << '\n';
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
start = clock();
cout << fixed << setprecision(12);
for (long long i = 1; i <= t; ++i) {
solve();
}
return 0;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
Smeke has decided to participate in AtCoder Beginner Contest (ABC) if his current rating is less than 1200, and participate in AtCoder Regular Contest (ARC) otherwise.
You are given Smeke's current rating, x. Print `ABC` if Smeke will participate in ABC, and print `ARC` otherwise.
Constraints
* 1 ≦ x ≦ 3{,}000
* x is an integer.
Input
The input is given from Standard Input in the following format:
x
Output
Print the answer.
Examples
Input
1000
Output
ABC
Input
2000
Output
ARC
### Response
```cpp
#include<iostream>
using namespace std;
int main(){
int x;
cin>>x;
x<1200?cout<<"ABC"<<endl:cout<<"ARC"<<endl;
return 0;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
For given two sequneces $A = \\{a_0, a_1, ..., a_{n-1}\\}$ and $B = \\{b_0, b_1, ..., b_{m-1}\\}$, determine whether all elements of $B$ are included in $A$. Note that, elements of $A$ and $B$ are sorted by ascending order respectively.
Constraints
* $1 \leq n, m \leq 200,000$
* $-1,000,000,000 \leq a_0 < a_1 < ... < a_{n-1} \leq 1,000,000,000$
* $-1,000,000,000 \leq b_0 < b_1 < ... < b_{m-1} \leq 1,000,000,000$
Input
The input is given in the following format.
$n$
$a_0 \; a_1 \; ,..., \; a_{n-1}$
$m$
$b_0 \; b_1 \; ,..., \; b_{m-1}$
The number of elements in $A$ and its elements $a_i$ are given in the first and second lines respectively. The number of elements in $B$ and its elements $b_i$ are given in the third and fourth lines respectively.
Output
Print 1, if $A$ contains all elements of $B$, otherwise 0.
Examples
Input
4
1 2 3 4
2
2 4
Output
1
Input
4
1 2 3 4
3
1 2 5
Output
0
### Response
```cpp
#pragma GCC optimize ("O3")
#include <iostream>
#include <iomanip>
#include <istream>
#include <ostream>
#include <sstream>
#include <iterator>
#include <vector>
#include <algorithm>
#include <queue>
#include <deque>
#include <list>
#include <stack>
#include <map>
#include <unordered_map>
#include <set>
#include <bitset>
#include <utility>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <string>
#include <ctime>
#include <cctype>
#include <cstdlib>
#define IINF 100000000
#define INF 1000000000000000000
#define MOD 1000000007
#define mod 1000000007
#define REP(i, a, n) for (ll i = a; i < (ll)(n); i++)
#define REPE(i, a, n) for (ll i = a; i <= (ll)(n); i++)
#define Endl endl
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define eb emplace_back
#define mmax(x,y)(x>y?x:y)
#define mmin(x,y)(x<y?x:y)
#define chmax(x,y) x=mmax(x,y)
#define chmin(x,y) x=mmin(x,y)
#define all(x) (x).begin(),(x).end()
#define siz(x) (ll)(x).size()
#define PI acos(-1.0)
using namespace std;
typedef long long int ll;
typedef unsigned long long int ull;
typedef long double ld;
typedef pair<int,int>Pin;
typedef pair<ll,ll>Pll;
template<class T> using V=vector<T>;
long long GCD(long long a, long long b) {return b?GCD(b,a%b):a;}
long long LCM(long long a, long long b) {return a/GCD(a,b)*b;}
int dx[4]={-1,0,1,0};
int dy[4]={0,-1,0,1};
int ddx[8]={-1,0,1,0,1,1,-1,-1};
int ddy[8]={0,-1,0,1,1,-1,1,-1};
ll cmp(pair<ll,ll>a,pair<ll,ll> b){
if(a.se!=b.se)
return a.se<b.se;
else
return a.fi<b.fi;
}
//----------------------------------------------------------------------
//----------------------------------------------------------------------
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
//-------------------------------
//ll begin_time=clock();
//-------------------------------
int n;cin>>n;
V<ll>a(n);
for(int i=0;i<n;i++)cin>>a[i];
int m;cin>>m;
V<ll>b(m);
for(int i=0;i<m;i++)cin>>b[i];
map<ll,int>mm;
for(int i=0;i<n;i++){
mm[a[i]]++;
}
bool abc=1;
for(int i=0;i<m;i++){
if(mm[b[i]]==0){
abc=0;
break;
}
}
if(abc==0)cout<<0<<endl;
else cout<<1<<Endl;
//-------------------------------
//ll end_time=clock();cout<<"time="<<end_time-begin_time<<"ms"<<endl;
//-------------------------------
return 0;
}
//----------------------------------------------------------------------
``` |
### Prompt
Please formulate a cpp solution to the following problem:
The start of the new academic year brought about the problem of accommodation students into dormitories. One of such dormitories has a a × b square meter wonder room. The caretaker wants to accommodate exactly n students there. But the law says that there must be at least 6 square meters per student in a room (that is, the room for n students must have the area of at least 6n square meters). The caretaker can enlarge any (possibly both) side of the room by an arbitrary positive integer of meters. Help him change the room so as all n students could live in it and the total area of the room was as small as possible.
Input
The first line contains three space-separated integers n, a and b (1 ≤ n, a, b ≤ 109) — the number of students and the sizes of the room.
Output
Print three integers s, a1 and b1 (a ≤ a1; b ≤ b1) — the final area of the room and its sizes. If there are multiple optimal solutions, print any of them.
Examples
Input
3 3 5
Output
18
3 6
Input
2 4 4
Output
16
4 4
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, a, b;
cin >> n >> a >> b;
n *= 6;
long long a2 = max(a, (n + b - 1) / b), b2 = b;
long long n2 = a2 * b2;
for (long long i = a; i <= n;) {
long long k = (n + i - 1) / i;
long long r = (k == 1 ? n : (n - 1) / (k - 1));
long long x = i * max(b, k);
if (x < n2) {
n2 = x;
a2 = i;
b2 = max(b, k);
}
i = r + 1;
}
cout << n2 << '\n' << a2 << ' ' << b2 << '\n';
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
Long story short, shashlik is Miroslav's favorite food. Shashlik is prepared on several skewers simultaneously. There are two states for each skewer: initial and turned over.
This time Miroslav laid out n skewers parallel to each other, and enumerated them with consecutive integers from 1 to n in order from left to right. For better cooking, he puts them quite close to each other, so when he turns skewer number i, it leads to turning k closest skewers from each side of the skewer i, that is, skewers number i - k, i - k + 1, ..., i - 1, i + 1, ..., i + k - 1, i + k (if they exist).
For example, let n = 6 and k = 1. When Miroslav turns skewer number 3, then skewers with numbers 2, 3, and 4 will come up turned over. If after that he turns skewer number 1, then skewers number 1, 3, and 4 will be turned over, while skewer number 2 will be in the initial position (because it is turned again).
As we said before, the art of cooking requires perfect timing, so Miroslav wants to turn over all n skewers with the minimal possible number of actions. For example, for the above example n = 6 and k = 1, two turnings are sufficient: he can turn over skewers number 2 and 5.
Help Miroslav turn over all n skewers.
Input
The first line contains two integers n and k (1 ≤ n ≤ 1000, 0 ≤ k ≤ 1000) — the number of skewers and the number of skewers from each side that are turned in one step.
Output
The first line should contain integer l — the minimum number of actions needed by Miroslav to turn over all n skewers. After than print l integers from 1 to n denoting the number of the skewer that is to be turned over at the corresponding step.
Examples
Input
7 2
Output
2
1 6
Input
5 1
Output
2
1 4
Note
In the first example the first operation turns over skewers 1, 2 and 3, the second operation turns over skewers 4, 5, 6 and 7.
In the second example it is also correct to turn over skewers 2 and 5, but turning skewers 2 and 4, or 1 and 5 are incorrect solutions because the skewer 3 is in the initial state after these operations.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int nax = 1000 * 1007;
int main() {
int n, k;
cin >> n >> k;
int ans = 0, curr = 0, index = 0;
for (int i = 0; i < k + 1; i++) {
curr = 0;
int j = i;
while (j < n) {
curr++;
j += (2 * k) + 1;
}
if (curr >= ans) {
ans = curr;
index = i;
}
}
cout << ans << endl;
for (int i = index + 1; i <= n; i += (2 * k) + 1) cout << i << " ";
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Last week, Hamed learned about a new type of equations in his math class called Modular Equations. Lets define i modulo j as the remainder of division of i by j and denote it by <image>. A Modular Equation, as Hamed's teacher described, is an equation of the form <image> in which a and b are two non-negative integers and x is a variable. We call a positive integer x for which <image> a solution of our equation.
Hamed didn't pay much attention to the class since he was watching a movie. He only managed to understand the definitions of these equations.
Now he wants to write his math exercises but since he has no idea how to do that, he asked you for help. He has told you all he knows about Modular Equations and asked you to write a program which given two numbers a and b determines how many answers the Modular Equation <image> has.
Input
In the only line of the input two space-separated integers a and b (0 ≤ a, b ≤ 109) are given.
Output
If there is an infinite number of answers to our equation, print "infinity" (without the quotes). Otherwise print the number of solutions of the Modular Equation <image>.
Examples
Input
21 5
Output
2
Input
9435152 272
Output
282
Input
10 10
Output
infinity
Note
In the first sample the answers of the Modular Equation are 8 and 16 since <image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, i;
cin >> a >> b;
if (a == b) {
cout << "infinity";
return 0;
} else if (b > a) {
cout << 0;
return 0;
}
long long c = a - b;
long long sq = sqrt(c);
long long ans = 0;
for (i = 1; i <= sq; i++) {
if (c % i == 0) {
if (i == (c / i)) {
if (i > b) ans++;
} else {
if (i > b) ans++;
if ((c / i) > b) ans++;
}
}
}
cout << ans;
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
Skyscraper "MinatoHarukas"
Mr. Port plans to start a new business renting one or more floors of the new skyscraper with one giga floors, MinatoHarukas. He wants to rent as many vertically adjacent floors as possible, because he wants to show advertisement on as many vertically adjacent windows as possible. The rent for one floor is proportional to the floor number, that is, the rent per month for the n-th floor is n times that of the first floor. Here, the ground floor is called the first floor in the American style, and basement floors are out of consideration for the renting. In order to help Mr. Port, you should write a program that computes the vertically adjacent floors satisfying his requirement and whose total rental cost per month is exactly equal to his budget.
For example, when his budget is 15 units, with one unit being the rent of the first floor, there are four possible rent plans, 1+2+3+4+5, 4+5+6, 7+8, and 15. For all of them, the sums are equal to 15. Of course in this example the rent of maximal number of the floors is that of 1+2+3+4+5, that is, the rent from the first floor to the fifth floor.
Input
The input consists of multiple datasets, each in the following format.
> b
>
A dataset consists of one line, the budget of Mr. Port b as multiples of the rent of the first floor. b is a positive integer satisfying 1 < b < 109.
The end of the input is indicated by a line containing a zero. The number of datasets does not exceed 1000.
Output
For each dataset, output a single line containing two positive integers representing the plan with the maximal number of vertically adjacent floors with its rent price exactly equal to the budget of Mr. Port. The first should be the lowest floor number and the second should be the number of floors.
Sample Input
15
16
2
3
9699690
223092870
847288609
900660121
987698769
999999999
0
Output for the Sample Input
1 5
16 1
2 1
1 2
16 4389
129 20995
4112949 206
15006 30011
46887 17718
163837 5994
Example
Input
15
16
2
3
9699690
223092870
847288609
900660121
987698769
999999999
0
Output
1 5
16 1
2 1
1 2
16 4389
129 20995
4112949 206
15006 30011
46887 17718
163837 5994
### Response
```cpp
#define D(x) cout << #x " = " << x << endl
#define DD(x, y) cout << "(" #x ", " #y ") = (" << x << ", " << y << ")" << endl
#define DDD(x, y, z) cout << "(" #x ", " #y ", " #z ") = (" << x << ", " << y << ", " << z << ")" << endl
#define DV(v) for (auto __macro_vi : v){ cout << __macro_vi << " ";} cout << endl;
#define DA(a, n) for (int __macro_i = 0; __macro_i < n; ++__macro_i) { cout << a[__macro_i] << " "; } cout << endl;
#define REP(i, n) for (int i = 0; i < n; ++i)
#define ALL(v) (v).begin(), (v).end()
#include<iostream>
#include<vector>
#include<cassert>
#include<cmath>
using namespace std;
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
while(1) {
int b;
cin >> b;
if (b == 0) break;
for (long long w = 100000; w >= 1; --w) {
long long lh = b - (w * w - w) / 2;
if (lh > 0 && lh % w == 0) {
cout << lh / w << " " << w << endl;
break;
}
}
}
}
``` |
### Prompt
Generate a cpp solution to the following problem:
Today Adilbek is taking his probability theory test. Unfortunately, when Adilbek arrived at the university, there had already been a long queue of students wanting to take the same test. Adilbek has estimated that he will be able to start the test only T seconds after coming.
Fortunately, Adilbek can spend time without revising any boring theorems or formulas. He has an app on this smartphone which contains n Japanese crosswords to solve. Adilbek has decided to solve them all one by one in the order they are listed in the app, without skipping any crossword. For each crossword, a number t_i is given that represents the time it takes an average crossword expert to solve this crossword (the time is given in seconds).
Adilbek is a true crossword expert, but, unfortunately, he is sometimes unlucky in choosing the way to solve the crossword. So, it takes him either t_i seconds or t_i + 1 seconds to solve the i-th crossword, equiprobably (with probability 1/2 he solves the crossword in exactly t_i seconds, and with probability 1/2 he has to spend an additional second to finish the crossword). All these events are independent.
After T seconds pass (or after solving the last crossword, if he manages to do it in less than T seconds), Adilbek closes the app (if he finishes some crossword at the same moment, that crossword is considered solved; otherwise Adilbek does not finish solving the current crossword at all). He thinks it would be an interesting probability theory problem to calculate E — the expected number of crosswords he will be able to solve completely. Can you calculate it?
Recall that the expected value of a discrete random variable is the probability-weighted average of all possible values — in this problem it means that the expected value of the number of solved crosswords can be calculated as E = ∑ _{i = 0}^{n} i p_i, where p_i is the probability that Adilbek will solve exactly i crosswords.
We can represent E as rational fraction P/Q with Q > 0. To give the answer, you should print P ⋅ Q^{-1} mod (10^9 + 7).
Input
The first line contains two integers n and T (1 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ T ≤ 2 ⋅ 10^{14}) — the number of crosswords and the time Adilbek has to spend, respectively.
The second line contains n integers t_1, t_2, ..., t_n (1 ≤ t_i ≤ 10^9), where t_i is the time it takes a crossword expert to solve the i-th crossword.
Note that Adilbek solves the crosswords in the order they are given in the input without skipping any of them.
Output
Print one integer — the expected value of the number of crosswords Adilbek solves in T seconds, expressed in the form of P ⋅ Q^{-1} mod (10^9 + 7).
Examples
Input
3 5
2 2 2
Output
750000007
Input
3 5
2 1 2
Output
125000003
Note
The answer for the first sample is equal to 14/8.
The answer for the second sample is equal to 17/8.
### Response
```cpp
#include <bits/stdc++.h>
const int mod = 1e9 + 7;
using namespace std;
int n, x = 0, y = 0, w = 1, fac[200010], ifac[200010], inv[200010], a[200010];
long long m, sum[200010];
int& qmo(int& x) { return x += (x >> 31) & mod; }
void init(int N) {
fac[0] = inv[1] = ifac[0] = 1;
for (int i = 1; i <= N; i++) fac[i] = 1ll * fac[i - 1] * i % mod;
for (int i = 2; i <= N; i++)
inv[i] = mod - 1ll * inv[mod % i] * (mod / i) % mod;
for (int i = 1; i <= N; i++) ifac[i] = 1ll * ifac[i - 1] * inv[i] % mod;
}
int C(int n, int m) {
if (n < m || m < 0) return 0;
return 1ll * fac[n] * ifac[n - m] % mod * ifac[m] % mod;
}
int S(int n, long long m) {
if (n < 0 || m < 0) return 0;
m = min(1ll * n, m);
while (x < n) {
qmo(qmo(w = w + w - mod) -= C(x, y));
x++;
}
while (x > n) {
w = 1ll * (w - C(x - 1, y) + mod) * inv[2] % mod;
x--;
}
while (y < m) {
qmo(w += C(x, y + 1) - mod);
y++;
}
while (y > m) {
qmo(w -= C(x, y));
y--;
}
return w;
}
int main() {
scanf("%d%lld", &n, &m);
init(max(n, 2));
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), sum[i] = sum[i - 1] + a[i];
int res = 0;
for (int i = 1, nw = inv[2]; i <= n; i++, nw = 1ll * nw * inv[2] % mod) {
res = (res + 1ll * nw * S(i, m - sum[i])) % mod;
}
printf("%d\n", res);
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
Andrew plays a game called "Civilization". Dima helps him.
The game has n cities and m bidirectional roads. The cities are numbered from 1 to n. Between any pair of cities there either is a single (unique) path, or there is no path at all. A path is such a sequence of distinct cities v1, v2, ..., vk, that there is a road between any contiguous cities vi and vi + 1 (1 ≤ i < k). The length of the described path equals to (k - 1). We assume that two cities lie in the same region if and only if, there is a path connecting these two cities.
During the game events of two types take place:
1. Andrew asks Dima about the length of the longest path in the region where city x lies.
2. Andrew asks Dima to merge the region where city x lies with the region where city y lies. If the cities lie in the same region, then no merging is needed. Otherwise, you need to merge the regions as follows: choose a city from the first region, a city from the second region and connect them by a road so as to minimize the length of the longest path in the resulting region. If there are multiple ways to do so, you are allowed to choose any of them.
Dima finds it hard to execute Andrew's queries, so he asks you to help him. Help Dima.
Input
The first line contains three integers n, m, q (1 ≤ n ≤ 3·105; 0 ≤ m < n; 1 ≤ q ≤ 3·105) — the number of cities, the number of the roads we already have and the number of queries, correspondingly.
Each of the following m lines contains two integers, ai and bi (ai ≠ bi; 1 ≤ ai, bi ≤ n). These numbers represent the road between cities ai and bi. There can be at most one road between two cities.
Each of the following q lines contains one of the two events in the following format:
* 1 xi. It is the request Andrew gives to Dima to find the length of the maximum path in the region that contains city xi (1 ≤ xi ≤ n).
* 2 xi yi. It is the request Andrew gives to Dima to merge the region that contains city xi and the region that contains city yi (1 ≤ xi, yi ≤ n). Note, that xi can be equal to yi.
Output
For each event of the first type print the answer on a separate line.
Examples
Input
6 0 6
2 1 2
2 3 4
2 5 6
2 3 2
2 5 3
1 1
Output
4
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
vector<int> roads[300001];
bool is_in[300001];
int tags[300001];
int dists[300001];
vector<int> tagged[300001];
pair<int, int> tag(int t, int n) {
tags[n] = t;
tagged[t].push_back(n);
is_in[n] = true;
int max1 = 0;
vector<int> vs;
for (auto m : roads[n]) {
if (is_in[m]) continue;
pair<int, int> p = tag(t, m);
max1 = max(max1, p.first);
vs.push_back(p.second);
}
int max2 = 0;
sort(vs.begin(), vs.end(), greater<int>());
if (vs.size()) {
max2 = 1 + vs[0];
max1 = max(max1, max2);
}
if (vs.size() > 1) {
max1 = max(max1, max2 + 1 + vs[1]);
}
return make_pair(max1, max2);
}
int main(int argc, char* argv[]) {
scanf("%d %d %d", &n, &m, &q);
for (int i = 0; i < m; ++i) {
int a, b;
scanf("%d %d", &a, &b);
roads[a].push_back(b);
roads[b].push_back(a);
}
for (int i = 0; i <= 300000; ++i) {
is_in[i] = false;
dists[i] = 0;
}
for (int i = 0; i <= 300000; ++i)
if (not is_in[i]) dists[i] = tag(i, i).first;
for (int i = 0; i < q; ++i) {
int req;
scanf("%d", &req);
if (1 == req) {
int x;
scanf("%d", &x);
printf("%d\n", dists[tags[x]]);
} else if (2 == req) {
int x, y;
scanf("%d %d", &x, &y);
int tag_x = tags[x], tag_y = tags[y];
if (tag_x == tag_y) continue;
int d = max(dists[tag_x], dists[tag_y]);
d = max(d, 1 + (dists[tag_x] + 1) / 2 + (dists[tag_y] + 1) / 2);
if (tagged[tag_x].size() < tagged[tag_y].size()) {
for (int n : tagged[tag_x]) {
tagged[tag_y].push_back(n);
tags[n] = tag_y;
}
tagged[tag_x].clear();
dists[tag_y] = d;
} else {
for (int n : tagged[tag_y]) {
tagged[tag_x].push_back(n);
tags[n] = tag_x;
}
tagged[tag_y].clear();
dists[tag_x] = d;
}
}
}
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Snuke found a record of a tree with N vertices in ancient ruins. The findings are as follows:
* The vertices of the tree were numbered 1,2,...,N, and the edges were numbered 1,2,...,N-1.
* Edge i connected Vertex a_i and b_i.
* The length of each edge was an integer between 1 and 10^{18} (inclusive).
* The sum of the shortest distances from Vertex i to Vertex 1,...,N was s_i.
From the information above, restore the length of each edge. The input guarantees that it is possible to determine the lengths of the edges consistently with the record. Furthermore, it can be proved that the length of each edge is uniquely determined in such a case.
Constraints
* 2 \leq N \leq 10^{5}
* 1 \leq a_i,b_i \leq N
* 1 \leq s_i \leq 10^{18}
* The given graph is a tree.
* All input values are integers.
* It is possible to consistently restore the lengths of the edges.
* In the restored graph, the length of each edge is an integer between 1 and 10^{18} (inclusive).
Input
Input is given from Standard Input in the following format:
N
a_1 b_1
:
a_{N-1} b_{N-1}
s_1 s_2 ... s_{N}
Output
Print N-1 lines. The i-th line must contain the length of Edge i.
Examples
Input
4
1 2
2 3
3 4
8 6 6 8
Output
1
2
1
Input
5
1 2
1 3
1 4
1 5
10 13 16 19 22
Output
1
2
3
4
Input
15
9 10
9 15
15 4
4 13
13 2
13 11
2 14
13 6
11 1
1 12
12 3
12 7
2 5
14 8
1154 890 2240 883 2047 2076 1590 1104 1726 1791 1091 1226 841 1000 901
Output
5
75
2
6
7
50
10
95
9
8
78
28
89
8
### Response
```cpp
#include <iostream>
#include <vector>
using namespace std;
long long n, a[100009], b[100009], c[100009], s[100009], dist[100009], dp[100009]; vector<int>x[100009]; bool used[100009];
vector<pair<long long, long long>>X[200009];
long long dfs(int pos, int depth) {
used[pos] = true;
dist[pos] = depth;
dp[pos] = 1;
for (int i = 0; i < x[pos].size(); i++) {
if (used[x[pos][i]] == true) continue;
dp[pos] += dfs(x[pos][i], depth + 1);
}
return dp[pos];
}
void dfs2(int pos, long long depth) {
if (used[pos] == true) return;
dist[pos] = depth; used[pos] = true;
for (int i = 0; i < X[pos].size(); i++) {
dfs2(X[pos][i].first, depth + X[pos][i].second);
}
}
int main() {
cin >> n;
for (int i = 1; i <= n - 1; i++) {
cin >> a[i] >> b[i];
x[a[i]].push_back(b[i]);
x[b[i]].push_back(a[i]);
}
for (int i = 1; i <= n; i++) cin >> s[i];
dfs(1, 0);
for (int i = 1; i <= n - 1; i++) {
if (dist[a[i]] > dist[b[i]]) swap(a[i], b[i]);
if (s[b[i]] - s[a[i]] == 0) continue;
else c[i] = (s[b[i]] - s[a[i]]) / (n - dp[b[i]] * 2);
}
for (int i = 1; i <= n - 1; i++) {
X[a[i]].push_back(make_pair(b[i], c[i]));
X[b[i]].push_back(make_pair(a[i], c[i]));
}
for (int i = 1; i <= n; i++) used[i] = false;
dfs2(1, 0);
long long sum = 0; for (int i = 1; i <= n; i++) sum += dist[i];
for (int i = 1; i <= n - 1; i++) {
if (c[i] == 0) c[i] = (s[1] - sum) / (n / 2);
}
for (int i = 1; i <= n - 1; i++) {
cout << c[i] << endl;
}
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
In some other world, today is the day before Christmas Eve.
Mr. Takaha is buying N items at a department store. The regular price of the i-th item (1 \leq i \leq N) is p_i yen (the currency of Japan).
He has a discount coupon, and can buy one item with the highest price for half the regular price. The remaining N-1 items cost their regular prices. What is the total amount he will pay?
Constraints
* 2 \leq N \leq 10
* 100 \leq p_i \leq 10000
* p_i is an even number.
Input
Input is given from Standard Input in the following format:
N
p_1
p_2
:
p_N
Output
Print the total amount Mr. Takaha will pay.
Examples
Input
3
4980
7980
6980
Output
15950
Input
4
4320
4320
4320
4320
Output
15120
### Response
```cpp
#include<iostream>
int main(){int n,i,A=0,M=0,p;std::cin>>n;for(i=n;i--;){std::cin>>p;M=M>p?M:p;A+=p;}std::cout<<A-M/2;}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
There is a square painted on a piece of paper, the square's side equals n meters. John Doe draws crosses on the square's perimeter. John paints the first cross in the lower left corner of the square. Then John moves along the square's perimeter in the clockwise direction (first upwards, then to the right, then downwards, then to the left and so on). Every time he walks (n + 1) meters, he draws a cross (see picture for clarifications).
John Doe stops only when the lower left corner of the square has two crosses. How many crosses will John draw?
<image> The figure shows the order in which John draws crosses for a square with side 4. The lower left square has two crosses. Overall John paints 17 crosses.
Input
The first line contains integer t (1 ≤ t ≤ 104) — the number of test cases.
The second line contains t space-separated integers ni (1 ≤ ni ≤ 109) — the sides of the square for each test sample.
Output
For each test sample print on a single line the answer to it, that is, the number of crosses John will draw as he will move along the square of the corresponding size. Print the answers to the samples in the order in which the samples are given in the input.
Please do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
3
4 8 100
Output
17
33
401
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, 1, 0, -1};
bool visited[100000];
bool check[100000];
long long int dis[100000];
int gcd(long long int x, long long int y) {
if (y == 0) return x;
return gcd(y, x % y);
}
int main() {
long long int t;
cin >> t;
long long int a[t];
for (int j = 0; j < t; j++) {
long long int n;
cin >> n;
long long int d, f, g, ans, m;
d = (n + 1) + (2 * n) + n - 1;
f = n + 1;
g = gcd(d, f);
m = (f / g);
ans = ((m * d) / f) + 1;
a[j] = ans;
}
for (int i = 0; i < t; i++) {
cout << a[i] << endl;
}
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
There are N slimes standing on a number line. The i-th slime from the left is at position x_i.
It is guaruanteed that 1 \leq x_1 < x_2 < \ldots < x_N \leq 10^{9}.
Niwango will perform N-1 operations. The i-th operation consists of the following procedures:
* Choose an integer k between 1 and N-i (inclusive) with equal probability.
* Move the k-th slime from the left, to the position of the neighboring slime to the right.
* Fuse the two slimes at the same position into one slime.
Find the total distance traveled by the slimes multiplied by (N-1)! (we can show that this value is an integer), modulo (10^{9}+7). If a slime is born by a fuse and that slime moves, we count it as just one slime.
Constraints
* 2 \leq N \leq 10^{5}
* 1 \leq x_1 < x_2 < \ldots < x_N \leq 10^{9}
* x_i is an integer.
Input
Input is given from Standard Input in the following format:
N
x_1 x_2 \ldots x_N
Output
Print the answer.
Examples
Input
3
1 2 3
Output
5
Input
12
161735902 211047202 430302156 450968417 628894325 707723857 731963982 822804784 880895728 923078537 971407775 982631932
Output
750927044
### Response
```cpp
#include <iostream>
using namespace std;
typedef long long ll;
const int MAX = 100010;
ll inv[MAX],fact[MAX],fi[MAX],mod = 1000000007;
void inverse(){
int i;
inv[1] = 1;
for(i=2;i<MAX;i++){
inv[i] = mod - (mod/i)*inv[mod%i]%mod;
}
fact[0] = fi[0] = 1;
for(i=1;i<MAX;i++){
fact[i] = fact[i-1]*i%mod;
fi[i] = (fi[i-1]*inv[i])%mod;
}
}
ll comb(int n,int k){
if(n<0 || k<0 || n<k){
return 0;
}else{
return fact[n]%mod*fi[k]%mod*fi[n-k]%mod;
}
}
ll x[100010],ans = 0,sum = 0;
int main(){
int i,n;
cin >> n;
for(i=0;i<n;i++){
cin >> x[i];
}
inverse();
for(i=1;i<n;i++){
sum += inv[i];
(ans += sum*(x[i] - x[i - 1])%mod) %= mod;
}
(ans *= fact[n - 1]) %= mod;
cout << ans << endl;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
Alice and Bob have decided to play the game "Rock, Paper, Scissors".
The game consists of several rounds, each round is independent of each other. In each round, both players show one of the following things at the same time: rock, paper or scissors. If both players showed the same things then the round outcome is a draw. Otherwise, the following rules applied:
* if one player showed rock and the other one showed scissors, then the player who showed rock is considered the winner and the other one is considered the loser;
* if one player showed scissors and the other one showed paper, then the player who showed scissors is considered the winner and the other one is considered the loser;
* if one player showed paper and the other one showed rock, then the player who showed paper is considered the winner and the other one is considered the loser.
Alice and Bob decided to play exactly n rounds of the game described above. Alice decided to show rock a_1 times, show scissors a_2 times and show paper a_3 times. Bob decided to show rock b_1 times, show scissors b_2 times and show paper b_3 times. Though, both Alice and Bob did not choose the sequence in which they show things. It is guaranteed that a_1 + a_2 + a_3 = n and b_1 + b_2 + b_3 = n.
Your task is to find two numbers:
1. the minimum number of round Alice can win;
2. the maximum number of rounds Alice can win.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 10^{9}) — the number of rounds.
The second line of the input contains three integers a_1, a_2, a_3 (0 ≤ a_i ≤ n) — the number of times Alice will show rock, scissors and paper, respectively. It is guaranteed that a_1 + a_2 + a_3 = n.
The third line of the input contains three integers b_1, b_2, b_3 (0 ≤ b_j ≤ n) — the number of times Bob will show rock, scissors and paper, respectively. It is guaranteed that b_1 + b_2 + b_3 = n.
Output
Print two integers: the minimum and the maximum number of rounds Alice can win.
Examples
Input
2
0 1 1
1 1 0
Output
0 1
Input
15
5 5 5
5 5 5
Output
0 15
Input
3
0 0 3
3 0 0
Output
3 3
Input
686
479 178 29
11 145 530
Output
22 334
Input
319
10 53 256
182 103 34
Output
119 226
Note
In the first example, Alice will not win any rounds if she shows scissors and then paper and Bob shows rock and then scissors. In the best outcome, Alice will win one round if she shows paper and then scissors, and Bob shows rock and then scissors.
In the second example, Alice will not win any rounds if Bob shows the same things as Alice each round.
In the third example, Alice always shows paper and Bob always shows rock so Alice will win all three rounds anyway.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
long long int n;
cin >> n;
int a1, a2, a3, b1, b2, b3;
cin >> a1 >> a2 >> a3;
cin >> b1 >> b2 >> b3;
int ansm = 0;
ansm += min(b2, a1) + min(a2, b3) + min(a3, b1);
int ansmi = 0;
ansmi = max((b1 - (a1 + a2)), b2 - (a3 + a2));
ansmi = max(ansmi, b3 - (a1 + a3));
if (ansmi < 0) ansmi = 0;
cout << ansmi << " " << ansm;
return 0;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
Vlad likes to eat in cafes very much. During his life, he has visited cafes n times. Unfortunately, Vlad started to feel that his last visits are not any different from each other. To fix that Vlad had a small research.
First of all, Vlad assigned individual indices to all cafes. Then, he wrote down indices of cafes he visited in a row, in order of visiting them. Now, Vlad wants to find such a cafe that his last visit to that cafe was before his last visits to every other cafe. In other words, he wants to find such a cafe that he hasn't been there for as long as possible. Help Vlad to find that cafe.
Input
In first line there is one integer n (1 ≤ n ≤ 2·105) — number of cafes indices written by Vlad.
In second line, n numbers a1, a2, ..., an (0 ≤ ai ≤ 2·105) are written — indices of cafes in order of being visited by Vlad. Vlad could visit some cafes more than once. Note that in numeration, some indices could be omitted.
Output
Print one integer — index of the cafe that Vlad hasn't visited for as long as possible.
Examples
Input
5
1 3 2 1 2
Output
3
Input
6
2 1 2 2 4 1
Output
2
Note
In first test, there are three cafes, and the last visits to cafes with indices 1 and 2 were after the last visit to cafe with index 3; so this cafe is the answer.
In second test case, there are also three cafes, but with indices 1, 2 and 4. Cafes with indices 1 and 4 were visited after the last visit of cafe with index 2, so the answer is 2. Note that Vlad could omit some numbers while numerating the cafes.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
vector<pair<int, bool>> a(n, {0, false});
set<int> v;
for (int i = 0; i < n; ++i) {
cin >> a[i].first;
v.insert(a[i].first);
}
for (int i = n - 1; i >= 0; --i) {
if (v.size() == 1) {
break;
}
if (!a[i].second) {
a[i].second = true;
v.erase(a[i].first);
}
}
for (auto i : v) {
cout << i;
}
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
You are given a string s such that each its character is either 1, 2, or 3. You have to choose the shortest contiguous substring of s such that it contains each of these three characters at least once.
A contiguous substring of string s is a string that can be obtained from s by removing some (possibly zero) characters from the beginning of s and some (possibly zero) characters from the end of s.
Input
The first line contains one integer t (1 ≤ t ≤ 20000) — the number of test cases.
Each test case consists of one line containing the string s (1 ≤ |s| ≤ 200000). It is guaranteed that each character of s is either 1, 2, or 3.
The sum of lengths of all strings in all test cases does not exceed 200000.
Output
For each test case, print one integer — the length of the shortest contiguous substring of s containing all three types of characters at least once. If there is no such substring, print 0 instead.
Example
Input
7
123
12222133333332
112233
332211
12121212
333333
31121
Output
3
3
4
4
0
0
4
Note
Consider the example test:
In the first test case, the substring 123 can be used.
In the second test case, the substring 213 can be used.
In the third test case, the substring 1223 can be used.
In the fourth test case, the substring 3221 can be used.
In the fifth test case, there is no character 3 in s.
In the sixth test case, there is no character 1 in s.
In the seventh test case, the substring 3112 can be used.
### Response
```cpp
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math,O3")
#pragma GCC target("avx,avx2,fma")
using namespace std;
const int len = 1000000;
int arr[len] = {0};
int siv() {
for (long long int i = 2; i < len; i++) {
for (long long int j = i * i; j < len; j += i) {
arr[j - 1] = 1;
}
}
}
long long divis(long long int n) {
if (n % 2 == 0) {
return 2;
} else {
for (int i = 3; i <= sqrt(n); i++) {
if (n % i == 0) {
return i;
}
}
}
return n;
}
bool chec(string s) {
int i;
for (i = 0; i < s.size() - 2; i++) {
if (s[i] != s[i + 1] && s[i] != s[i + 2] && s[i + 1] != s[i + 2]) {
return true;
break;
}
}
return false;
}
int main() {
long long int t;
cin >> t;
while (t--) {
long long int n, i, j, k, l, x, y, z, sum = 0, o = 0, mind = LLONG_MAX,
maxd, multii;
vector<long long int> v, vv;
string s;
cin >> s;
set<char> tem(s.begin(), s.end());
if (tem.size() == 1 || tem.size() == 2) {
cout << 0 << endl;
} else if (chec(s) == true) {
cout << 3 << endl;
} else {
y = 0;
for (i = 0; i < s.size() - 2; i++) {
if (s[i] != s[i + 1]) {
j = i + 1;
x = j;
j++;
while (s[x] == s[j]) {
j++;
y++;
}
y++;
if (s[i] != s[x] && s[i] != s[j] && j < s.size()) {
mind = min(mind, 1 + y + 1);
y = 0;
}
}
y = 0;
}
cout << mind << endl;
}
}
return 0;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
Polycarp has guessed three positive integers a, b and c. He keeps these numbers in secret, but he writes down four numbers on a board in arbitrary order — their pairwise sums (three numbers) and sum of all three numbers (one number). So, there are four numbers on a board in random order: a+b, a+c, b+c and a+b+c.
You have to guess three numbers a, b and c using given numbers. Print three guessed integers in any order.
Pay attention that some given numbers a, b and c can be equal (it is also possible that a=b=c).
Input
The only line of the input contains four positive integers x_1, x_2, x_3, x_4 (2 ≤ x_i ≤ 10^9) — numbers written on a board in random order. It is guaranteed that the answer exists for the given number x_1, x_2, x_3, x_4.
Output
Print such positive integers a, b and c that four numbers written on a board are values a+b, a+c, b+c and a+b+c written in some order. Print a, b and c in any order. If there are several answers, you can print any. It is guaranteed that the answer exists.
Examples
Input
3 6 5 4
Output
2 1 3
Input
40 40 40 60
Output
20 20 20
Input
201 101 101 200
Output
1 100 100
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int x1, x2, x3, x4;
cin >> x1 >> x2 >> x3 >> x4;
int maxi = INT_MIN;
maxi = max(x1, max(max(x2, x3), x4));
if (maxi == x1) {
cout << maxi - x2 << " " << maxi - x3 << " " << maxi - x4;
} else if (maxi == x2) {
cout << maxi - x1 << " " << maxi - x3 << " " << maxi - x4;
} else if (maxi == x3) {
cout << maxi - x1 << " " << maxi - x2 << " " << maxi - x4;
} else {
cout << maxi - x1 << " " << maxi - x2 << " " << maxi - x3;
}
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
One day in the IT lesson Anna and Maria learned about the lexicographic order.
String x is lexicographically less than string y, if either x is a prefix of y (and x ≠ y), or there exists such i (1 ≤ i ≤ min(|x|, |y|)), that xi < yi, and for any j (1 ≤ j < i) xj = yj. Here |a| denotes the length of the string a. The lexicographic comparison of strings is implemented by operator < in modern programming languages.
The teacher gave Anna and Maria homework. She gave them a string of length n. They should write out all substrings of the given string, including the whole initial string, and the equal substrings (for example, one should write out the following substrings from the string "aab": "a", "a", "aa", "ab", "aab", "b"). The resulting strings should be sorted in the lexicographical order. The cunning teacher doesn't want to check all these strings. That's why she said to find only the k-th string from the list. Help Anna and Maria do the homework.
Input
The first line contains a non-empty string that only consists of small Latin letters ("a"-"z"), whose length does not exceed 105. The second line contains the only integer k (1 ≤ k ≤ 105).
Output
Print the string Anna and Maria need — the k-th (in the lexicographical order) substring of the given string. If the total number of substrings is less than k, print a string saying "No such line." (without the quotes).
Examples
Input
aa
2
Output
a
Input
abc
5
Output
bc
Input
abab
7
Output
b
Note
In the second sample before string "bc" follow strings "a", "ab", "abc", "b".
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
set<pair<string, long long> > Set;
string s;
long long k, len;
void work() {
for (long long i = 0; i < len; i++) {
string tmp;
tmp += s[i];
Set.insert(make_pair(tmp, i));
}
pair<string, long long> p;
while (k--) {
p = *Set.begin();
Set.erase(Set.begin());
if (p.second == len - 1) continue;
pair<string, long long> t;
t.first = p.first + s[++p.second];
t.second = p.second;
Set.insert(t);
}
cout << p.first << endl;
}
int main() {
while (cin >> s >> k) {
Set.clear();
len = s.size();
if (k > len * (len + 1) / 2) {
puts("No such line.");
continue;
}
work();
}
return 0;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
You are given a huge integer a consisting of n digits (n is between 1 and 3 ⋅ 10^5, inclusive). It may contain leading zeros.
You can swap two digits on adjacent (neighboring) positions if the swapping digits are of different parity (that is, they have different remainders when divided by 2).
For example, if a = 032867235 you can get the following integers in a single operation:
* 302867235 if you swap the first and the second digits;
* 023867235 if you swap the second and the third digits;
* 032876235 if you swap the fifth and the sixth digits;
* 032862735 if you swap the sixth and the seventh digits;
* 032867325 if you swap the seventh and the eighth digits.
Note, that you can't swap digits on positions 2 and 4 because the positions are not adjacent. Also, you can't swap digits on positions 3 and 4 because the digits have the same parity.
You can perform any number (possibly, zero) of such operations.
Find the minimum integer you can obtain.
Note that the resulting integer also may contain leading zeros.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases in the input.
The only line of each test case contains the integer a, its length n is between 1 and 3 ⋅ 10^5, inclusive.
It is guaranteed that the sum of all values n does not exceed 3 ⋅ 10^5.
Output
For each test case print line — the minimum integer you can obtain.
Example
Input
3
0709
1337
246432
Output
0079
1337
234642
Note
In the first test case, you can perform the following sequence of operations (the pair of swapped digits is highlighted): 0 \underline{70} 9 → 0079.
In the second test case, the initial integer is optimal.
In the third test case you can perform the following sequence of operations: 246 \underline{43} 2 → 24 \underline{63}42 → 2 \underline{43} 642 → 234642.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long t;
cin >> t;
while (t--) {
string s;
cin >> s;
long n = s.size();
queue<char> q1, q2;
for (long i = 0; i < n; i++) {
if ((s[i] - '0') % 2)
q1.push(s[i]);
else
q2.push(s[i]);
}
string s1 = "";
while (!q1.empty() && !q2.empty()) {
s1 += min(q1.front(), q2.front());
if (q1.front() < q2.front())
q1.pop();
else
q2.pop();
}
while (!q1.empty()) {
s1 += q1.front();
q1.pop();
}
while (!q2.empty()) {
s1 += q2.front();
q2.pop();
}
cout << s1 << "\n";
}
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
You already know that Valery's favorite sport is biathlon. Due to your help, he learned to shoot without missing, and his skills are unmatched at the shooting range. But now a smaller task is to be performed, he should learn to complete the path fastest.
The track's map is represented by a rectangle n × m in size divided into squares. Each square is marked with a lowercase Latin letter (which means the type of the plot), with the exception of the starting square (it is marked with a capital Latin letters S) and the terminating square (it is marked with a capital Latin letter T). The time of movement from one square to another is equal to 1 minute. The time of movement within the cell can be neglected. We can move from the cell only to side-adjacent ones, but it is forbidden to go beyond the map edges. Also the following restriction is imposed on the path: it is not allowed to visit more than k different types of squares (squares of one type can be visited an infinite number of times). Squares marked with S and T have no type, so they are not counted. But S must be visited exactly once — at the very beginning, and T must be visited exactly once — at the very end.
Your task is to find the path from the square S to the square T that takes minimum time. Among all shortest paths you should choose the lexicographically minimal one. When comparing paths you should lexicographically represent them as a sequence of characters, that is, of plot types.
Input
The first input line contains three integers n, m and k (1 ≤ n, m ≤ 50, n·m ≥ 2, 1 ≤ k ≤ 4). Then n lines contain the map. Each line has the length of exactly m characters and consists of lowercase Latin letters and characters S and T. It is guaranteed that the map contains exactly one character S and exactly one character T.
Pretest 12 is one of the maximal tests for this problem.
Output
If there is a path that satisfies the condition, print it as a sequence of letters — the plot types. Otherwise, print "-1" (without quotes). You shouldn't print the character S in the beginning and T in the end.
Note that this sequence may be empty. This case is present in pretests. You can just print nothing or print one "End of line"-character. Both will be accepted.
Examples
Input
5 3 2
Sba
ccc
aac
ccc
abT
Output
bcccc
Input
3 4 1
Sxyy
yxxx
yyyT
Output
xxxx
Input
1 3 3
TyS
Output
y
Input
1 4 1
SxyT
Output
-1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 55;
int R, C, KK;
char ssG[N][N];
int stx, sty;
struct nodexx {
string str;
int x, y, val;
nodexx(string str00, int x00, int y00, int val00) {
str = str00, x = x00, y = y00, val = val00;
}
bool operator<(const nodexx t) const {
int lenaa = str.size(), lenbb = t.str.size();
if (lenaa - lenbb) return lenaa > lenbb;
return str > t.str;
}
};
priority_queue<nodexx> QQ;
set<pair<pair<int, int>, int> > SET;
int has[N][N];
int dirc[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
bool Judge(int x) {
int cnt = 0;
while (x > 0) {
cnt += x % 2;
x >>= 1;
}
return cnt <= KK;
}
string BFS() {
SET.clear();
memset(has, 0, sizeof has);
while (QQ.size()) QQ.pop();
QQ.push(nodexx("", stx, sty, 0));
SET.insert(make_pair(make_pair(stx, sty), 0));
int e, r, c, t;
while (QQ.size()) {
nodexx XA = QQ.top();
QQ.pop();
for (e = 0; e < 4; e++) {
r = XA.x + dirc[e][0], c = XA.y + dirc[e][1];
if (r >= 0 && r < R && c >= 0 && c < C && ssG[r][c] != 'S') {
if (ssG[r][c] == 'T') return XA.str;
t = XA.val | (1 << (ssG[r][c] - 'a'));
if (Judge(t) && SET.count(make_pair(make_pair(r, c), t)) == 0) {
if (has[r][c] && (has[r][c] & t) == has[r][c]) continue;
has[r][c] = t;
SET.insert(make_pair(make_pair(r, c), t));
QQ.push(nodexx(XA.str + ssG[r][c], r, c, t));
}
}
}
}
return "-1";
}
void cyh() { cout << BFS() << endl; }
int main() {
int e, f;
while (cin >> R >> C >> KK) {
for (e = 0; e < R; e++) {
scanf("%s", ssG[e]);
for (f = 0; f < C; f++)
if (ssG[e][f] == 'S') stx = e, sty = f;
}
cyh();
}
return 0;
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
We start with a string s consisting only of the digits 1, 2, or 3. The length of s is denoted by |s|. For each i from 1 to |s|, the i-th character of s is denoted by s_i.
There is one cursor. The cursor's location ℓ is denoted by an integer in \{0, …, |s|\}, with the following meaning:
* If ℓ = 0, then the cursor is located before the first character of s.
* If ℓ = |s|, then the cursor is located right after the last character of s.
* If 0 < ℓ < |s|, then the cursor is located between s_ℓ and s_{ℓ+1}.
We denote by s_left the string to the left of the cursor and s_right the string to the right of the cursor.
We also have a string c, which we call our clipboard, which starts out as empty. There are three types of actions:
* The Move action. Move the cursor one step to the right. This increments ℓ once.
* The Cut action. Set c ← s_right, then set s ← s_left.
* The Paste action. Append the value of c to the end of the string s. Note that this doesn't modify c.
The cursor initially starts at ℓ = 0. Then, we perform the following procedure:
1. Perform the Move action once.
2. Perform the Cut action once.
3. Perform the Paste action s_ℓ times.
4. If ℓ = x, stop. Otherwise, return to step 1.
You're given the initial string s and the integer x. What is the length of s when the procedure stops? Since this value may be very large, only find it modulo 10^9 + 7.
It is guaranteed that ℓ ≤ |s| at any time.
Input
The first line of input contains a single integer t (1 ≤ t ≤ 1000) denoting the number of test cases. The next lines contain descriptions of the test cases.
The first line of each test case contains a single integer x (1 ≤ x ≤ 10^6). The second line of each test case consists of the initial string s (1 ≤ |s| ≤ 500). It is guaranteed, that s consists of the characters "1", "2", "3".
It is guaranteed that the sum of x in a single file is at most 10^6. It is guaranteed that in each test case before the procedure will stop it will be true that ℓ ≤ |s| at any time.
Output
For each test case, output a single line containing a single integer denoting the answer for that test case modulo 10^9 + 7.
Example
Input
4
5
231
7
2323
6
333
24
133321333
Output
25
1438
1101
686531475
Note
Let's illustrate what happens with the first test case. Initially, we have s = 231. Initially, ℓ = 0 and c = \varepsilon (the empty string). The following things happen if we follow the procedure above:
* Step 1, Move once: we get ℓ = 1.
* Step 2, Cut once: we get s = 2 and c = 31.
* Step 3, Paste s_ℓ = 2 times: we get s = 23131.
* Step 4: ℓ = 1 not= x = 5, so we return to step 1.
* Step 1, Move once: we get ℓ = 2.
* Step 2, Cut once: we get s = 23 and c = 131.
* Step 3, Paste s_ℓ = 3 times: we get s = 23131131131.
* Step 4: ℓ = 2 not= x = 5, so we return to step 1.
* Step 1, Move once: we get ℓ = 3.
* Step 2, Cut once: we get s = 231 and c = 31131131.
* Step 3, Paste s_ℓ = 1 time: we get s = 23131131131.
* Step 4: ℓ = 3 not= x = 5, so we return to step 1.
* Step 1, Move once: we get ℓ = 4.
* Step 2, Cut once: we get s = 2313 and c = 1131131.
* Step 3, Paste s_ℓ = 3 times: we get s = 2313113113111311311131131.
* Step 4: ℓ = 4 not= x = 5, so we return to step 1.
* Step 1, Move once: we get ℓ = 5.
* Step 2, Cut once: we get s = 23131 and c = 13113111311311131131.
* Step 3, Paste s_ℓ = 1 times: we get s = 2313113113111311311131131.
* Step 4: ℓ = 5 = x, so we stop.
At the end of the procedure, s has length 25.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int DIV = 1000000007;
int main(int argc, char* argv[]) {
FILE* f = stdin;
int t;
fscanf(f, "%d", &t);
vector<char> s(1000000);
for (int test = 0; test < t; test++) {
int x;
fscanf(f, "%d", &x);
long long len = 0;
char c = 0;
while (c < '0' || c > '9') c = fgetc(f);
while (c >= '0' && c <= '9') {
s[len] = c;
len++;
if (feof(f)) break;
c = fgetc(f);
}
int slenOld = len;
for (int l = 1; l <= x; l++) {
long long add = len - l;
if (add < 0) add += DIV;
add *= (s[l - 1] - '1');
len = (len + add) % DIV;
if (slenOld < x) {
int slen = std::min((long long)x, add + slenOld);
for (int i = slenOld; i < slen; i++) s[i] = s[l + (i - slenOld)];
slenOld = slen;
}
}
printf("%I64d\n", len);
}
return 0;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
One day three best friends Petya, Vasya and Tonya decided to form a team and take part in programming contests. Participants are usually offered several problems during programming contests. Long before the start the friends decided that they will implement a problem if at least two of them are sure about the solution. Otherwise, the friends won't write the problem's solution.
This contest offers n problems to the participants. For each problem we know, which friend is sure about the solution. Help the friends find the number of problems for which they will write a solution.
Input
The first input line contains a single integer n (1 ≤ n ≤ 1000) — the number of problems in the contest. Then n lines contain three integers each, each integer is either 0 or 1. If the first number in the line equals 1, then Petya is sure about the problem's solution, otherwise he isn't sure. The second number shows Vasya's view on the solution, the third number shows Tonya's view. The numbers on the lines are separated by spaces.
Output
Print a single integer — the number of problems the friends will implement on the contest.
Examples
Input
3
1 1 0
1 1 1
1 0 0
Output
2
Input
2
1 0 0
0 1 1
Output
1
Note
In the first sample Petya and Vasya are sure that they know how to solve the first problem and all three of them know how to solve the second problem. That means that they will write solutions for these problems. Only Petya is sure about the solution for the third problem, but that isn't enough, so the friends won't take it.
In the second sample the friends will only implement the second problem, as Vasya and Tonya are sure about the solution.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int count = 0;
while (n--) {
int a, b, c;
cin >> a >> b >> c;
if (a + b + c >= 2) count++;
}
cout << count << endl;
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
Kevin has just recevied his disappointing results on the USA Identification of Cows Olympiad (USAICO) in the form of a binary string of length n. Each character of Kevin's string represents Kevin's score on one of the n questions of the olympiad—'1' for a correctly identified cow and '0' otherwise.
However, all is not lost. Kevin is a big proponent of alternative thinking and believes that his score, instead of being the sum of his points, should be the length of the longest alternating subsequence of his string. Here, we define an alternating subsequence of a string as a not-necessarily contiguous subsequence where no two consecutive elements are equal. For example, {0, 1, 0, 1}, {1, 0, 1}, and {1, 0, 1, 0} are alternating sequences, while {1, 0, 0} and {0, 1, 0, 1, 1} are not.
Kevin, being the sneaky little puffball that he is, is willing to hack into the USAICO databases to improve his score. In order to be subtle, he decides that he will flip exactly one substring—that is, take a contiguous non-empty substring of his score and change all '0's in that substring to '1's and vice versa. After such an operation, Kevin wants to know the length of the longest possible alternating subsequence that his string could have.
Input
The first line contains the number of questions on the olympiad n (1 ≤ n ≤ 100 000).
The following line contains a binary string of length n representing Kevin's results on the USAICO.
Output
Output a single integer, the length of the longest possible alternating subsequence that Kevin can create in his string after flipping a single substring.
Examples
Input
8
10000011
Output
5
Input
2
01
Output
2
Note
In the first sample, Kevin can flip the bolded substring '10000011' and turn his string into '10011011', which has an alternating subsequence of length 5: '10011011'.
In the second sample, Kevin can flip the entire string and still have the same score.
### Response
```cpp
#include <bits/stdc++.h>
int main() {
std::ios_base::sync_with_stdio(false);
int N, sol = 1;
std::string S;
std::cin >> N >> S;
for (int i = 0; i < N - 1; i++) sol += (S[i] != S[i + 1]);
std::cout << std::min(N, sol + 2);
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
You are given a tree consisting of n vertices. A tree is a connected undirected graph with n-1 edges. Each vertex v of this tree has a color assigned to it (a_v = 1 if the vertex v is white and 0 if the vertex v is black).
You have to solve the following problem for each vertex v: what is the maximum difference between the number of white and the number of black vertices you can obtain if you choose some subtree of the given tree that contains the vertex v? The subtree of the tree is the connected subgraph of the given tree. More formally, if you choose the subtree that contains cnt_w white vertices and cnt_b black vertices, you have to maximize cnt_w - cnt_b.
Input
The first line of the input contains one integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of vertices in the tree.
The second line of the input contains n integers a_1, a_2, ..., a_n (0 ≤ a_i ≤ 1), where a_i is the color of the i-th vertex.
Each of the next n-1 lines describes an edge of the tree. Edge i is denoted by two integers u_i and v_i, the labels of vertices it connects (1 ≤ u_i, v_i ≤ n, u_i ≠ v_i).
It is guaranteed that the given edges form a tree.
Output
Print n integers res_1, res_2, ..., res_n, where res_i is the maximum possible difference between the number of white and black vertices in some subtree that contains the vertex i.
Examples
Input
9
0 1 1 1 0 0 0 0 1
1 2
1 3
3 4
3 5
2 6
4 7
6 8
5 9
Output
2 2 2 2 2 1 1 0 2
Input
4
0 0 1 0
1 2
1 3
1 4
Output
0 -1 1 -1
Note
The first example is shown below:
<image>
The black vertices have bold borders.
In the second example, the best subtree for vertices 2, 3 and 4 are vertices 2, 3 and 4 correspondingly. And the best subtree for the vertex 1 is the subtree consisting of vertices 1 and 3.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[200005];
int col[200005];
int dp1[200005];
int dp2[200005];
void dfs1(int node, int pn) {
dp1[node] = -1;
if (col[node]) dp1[node] = 1;
for (int i = 0; i < adj[node].size(); i++)
if (adj[node][i] != pn) {
dfs1(adj[node][i], node);
if (dp1[adj[node][i]] > 0) dp1[node] += dp1[adj[node][i]];
}
return;
}
void dfs2(int node, int pn, int up) {
dp2[node] = dp1[node] + up;
for (int i = 0; i < adj[node].size(); i++)
if (adj[node][i] != pn) {
int top = dp1[node] - max(0, dp1[adj[node][i]]) + up;
dfs2(adj[node][i], node, max(top, 0));
}
return;
}
int main() {
int n, x, y;
cin >> n;
for (int i = 1; i <= n; i++) cin >> col[i];
for (int i = 0; i < n - 1; i++) {
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
dfs1(1, -1);
dfs2(1, -1, 0);
for (int i = 1; i <= n; i++) cout << dp2[i] << " ";
cout << endl;
return 0;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
You are playing the game "Arranging The Sheep". The goal of this game is to make the sheep line up. The level in the game is described by a string of length n, consisting of the characters '.' (empty space) and '*' (sheep). In one move, you can move any sheep one square to the left or one square to the right, if the corresponding square exists and is empty. The game ends as soon as the sheep are lined up, that is, there should be no empty cells between any sheep.
For example, if n=6 and the level is described by the string "**.*..", then the following game scenario is possible:
* the sheep at the 4 position moves to the right, the state of the level: "**..*.";
* the sheep at the 2 position moves to the right, the state of the level: "*.*.*.";
* the sheep at the 1 position moves to the right, the state of the level: ".**.*.";
* the sheep at the 3 position moves to the right, the state of the level: ".*.**.";
* the sheep at the 2 position moves to the right, the state of the level: "..***.";
* the sheep are lined up and the game ends.
For a given level, determine the minimum number of moves you need to make to complete the level.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4). Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 10^6).
The second line of each test case contains a string of length n, consisting of the characters '.' (empty space) and '*' (sheep) — the description of the level.
It is guaranteed that the sum of n over all test cases does not exceed 10^6.
Output
For each test case output the minimum number of moves you need to make to complete the level.
Example
Input
5
6
**.*..
5
*****
3
.*.
3
...
10
*.*...*.**
Output
1
0
0
0
9
### Response
```cpp
#include<iostream>
#include<cmath>
using namespace std;
int main(){
long long int t; cin>>t;
for(long int x=0;x<t;x++){
long long int n; cin>>n;
long long int sheep=0;
char arr[n];
for(long long int i=0;i<n;i++){
cin>>arr[i];
if(arr[i]=='*')sheep++;
}
long long int middle=(sheep-1)/2;
long long int pos_sheep[sheep];
long long int y=0;
for(long long int i=0;i<n;i++){
if(arr[i]=='*'){
pos_sheep[y]=i;
y++;
}
}
long long int moves=0;
for(long long int i=0;i<sheep;i++){
moves+=abs(pos_sheep[i]-pos_sheep[middle]+(middle-i));
}
cout<<moves<<endl;
}
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
A way to make a new task is to make it nondeterministic or probabilistic. For example, the hard task of Topcoder SRM 595, Constellation, is the probabilistic version of a convex hull.
Let's try to make a new task. Firstly we will use the following task. There are n people, sort them by their name. It is just an ordinary sorting problem, but we can make it more interesting by adding nondeterministic element. There are n people, each person will use either his/her first name or last name as a handle. Can the lexicographical order of the handles be exactly equal to the given permutation p?
More formally, if we denote the handle of the i-th person as hi, then the following condition must hold: <image>.
Input
The first line contains an integer n (1 ≤ n ≤ 105) — the number of people.
The next n lines each contains two strings. The i-th line contains strings fi and si (1 ≤ |fi|, |si| ≤ 50) — the first name and last name of the i-th person. Each string consists only of lowercase English letters. All of the given 2n strings will be distinct.
The next line contains n distinct integers: p1, p2, ..., pn (1 ≤ pi ≤ n).
Output
If it is possible, output "YES", otherwise output "NO".
Examples
Input
3
gennady korotkevich
petr mitrichev
gaoyuan chen
1 2 3
Output
NO
Input
3
gennady korotkevich
petr mitrichev
gaoyuan chen
3 1 2
Output
YES
Input
2
galileo galilei
nicolaus copernicus
2 1
Output
YES
Input
10
rean schwarzer
fei claussell
alisa reinford
eliot craig
laura arseid
jusis albarea
machias regnitz
sara valestin
emma millstein
gaius worzel
1 2 3 4 5 6 7 8 9 10
Output
NO
Input
10
rean schwarzer
fei claussell
alisa reinford
eliot craig
laura arseid
jusis albarea
machias regnitz
sara valestin
emma millstein
gaius worzel
2 4 9 6 5 7 1 3 8 10
Output
YES
Note
In example 1 and 2, we have 3 people: tourist, Petr and me (cgy4ever). You can see that whatever handle is chosen, I must be the first, then tourist and Petr must be the last.
In example 3, if Copernicus uses "copernicus" as his handle, everything will be alright.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, k, n;
cin >> n;
string a, b;
vector<pair<string, string> > name;
vector<int> pos;
pos.resize(n);
for (i = 0; i < n; i++) {
cin >> a >> b;
name.push_back(make_pair(a, b));
}
for (i = 0; i < n; i++) cin >> pos[i];
bool dp[100005][2];
dp[0][0] = true;
dp[0][1] = true;
for (i = 1; i < n; i++) {
j = pos[i] - 1;
k = pos[i - 1] - 1;
dp[i][0] = false;
dp[i][1] = false;
if (dp[i - 1][0] == true && name[j].first > name[k].first) {
dp[i][0] = true;
}
if (dp[i - 1][1] == true && name[j].first > name[k].second) {
dp[i][0] = true;
}
if (dp[i - 1][0] == true && name[j].second > name[k].first) {
dp[i][1] = true;
}
if (dp[i - 1][1] == true && name[j].second > name[k].second) {
dp[i][1] = true;
}
}
if (dp[n - 1][0] || dp[n - 1][1])
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
The appearance of the sun is called "sunrise" and the hiding is called "sunset". What is the exact time when the sun is on the horizon?
As shown in the figure below, we will represent the sun as a circle and the horizon as a straight line. At this time, the time of "sunrise" and "sunset" of the sun is the moment when the upper end of the circle representing the sun coincides with the straight line representing the horizon. After sunrise, the daytime is when the top of the circle is above the straight line, and nighttime is when the circle is completely hidden below the straight line.
<image>
Create a program that inputs the height from the horizon to the center of the sun at a certain time and the radius of the sun, and outputs whether the time is "daytime", "sunrise or sunset", or "nighttime".
Input
The input is given in the following format.
H R
The input consists of one line and is given the integer H (-1000 ≤ H ≤ 1000), which represents the height from the horizon at a certain time to the center of the sun, and the integer R (1 ≤ R ≤ 1000), which represents the radius. However, H is 0 when the center of the sun is on the horizon, positive when it is above it, and negative when it is below it.
Output
Outputs "1" in the daytime, "0" in the sunrise or sunset, and "-1" in the nighttime on one line.
Examples
Input
-3 3
Output
0
Input
3 3
Output
1
Input
-4 3
Output
-1
### Response
```cpp
#include<iostream>
using namespace std;
int main(){
int h,r;
cin>>h>>r;
if(h+r>0){
cout<<1<<"\n";
}
if(h+r==0){
cout<<0<<"\n";
}
if(h+r<0){
cout<<-1<<"\n";
}
return 0;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
You are given a string s, consisting of lowercase English letters, and the integer m.
One should choose some symbols from the given string so that any contiguous subsegment of length m has at least one selected symbol. Note that here we choose positions of symbols, not the symbols themselves.
Then one uses the chosen symbols to form a new string. All symbols from the chosen position should be used, but we are allowed to rearrange them in any order.
Formally, we choose a subsequence of indices 1 ≤ i1 < i2 < ... < it ≤ |s|. The selected sequence must meet the following condition: for every j such that 1 ≤ j ≤ |s| - m + 1, there must be at least one selected index that belongs to the segment [j, j + m - 1], i.e. there should exist a k from 1 to t, such that j ≤ ik ≤ j + m - 1.
Then we take any permutation p of the selected indices and form a new string sip1sip2... sipt.
Find the lexicographically smallest string, that can be obtained using this procedure.
Input
The first line of the input contains a single integer m (1 ≤ m ≤ 100 000).
The second line contains the string s consisting of lowercase English letters. It is guaranteed that this string is non-empty and its length doesn't exceed 100 000. It is also guaranteed that the number m doesn't exceed the length of the string s.
Output
Print the single line containing the lexicographically smallest string, that can be obtained using the procedure described above.
Examples
Input
3
cbabc
Output
a
Input
2
abcab
Output
aab
Input
3
bcabcbaccba
Output
aaabb
Note
In the first sample, one can choose the subsequence {3} and form a string "a".
In the second sample, one can choose the subsequence {1, 2, 4} (symbols on this positions are 'a', 'b' and 'a') and rearrange the chosen symbols to form a string "aab".
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int N;
string s;
int pre[26][100000];
int no[26];
int32_t main() {
ios_base::sync_with_stdio(false);
if (fopen("cf724d.in", "r")) {
freopen("cf724d.in", "r", stdin);
freopen("cf724d.out", "w", stdout);
}
cin >> N >> s;
for (char i = 'a'; i <= 'z'; i++) {
pre[i - 'a'][0] = (bool)(s[0] <= i);
for (int j = 1; j < s.length(); j++) {
pre[i - 'a'][j] = pre[i - 'a'][j - 1] + (bool)(s[j] <= i);
}
}
for (int i = 0; i < 26; i++) {
bool trash = false;
if (pre[i][N - 1] == 0) {
no[i] = pre[i][s.length() - 1];
if (i) {
no[i] -= pre[i - 1][s.length() - 1];
}
continue;
}
for (int j = N; j < s.length(); j++) {
if (pre[i][j] - pre[i][j - N] == 0) {
no[i] = pre[i][s.length() - 1];
if (i) {
no[i] -= pre[i - 1][s.length() - 1];
}
trash = true;
break;
}
}
if (trash) {
continue;
}
int prevtaken = -1, preval;
for (int j = 0; j < s.length(); j++) {
if (j - prevtaken > N) {
prevtaken = preval;
no[i]++;
}
if (s[j] != 'a' + i) {
if (s[j] < 'a' + i) {
prevtaken = j;
}
continue;
}
preval = j;
}
if (s.length() - prevtaken > N) {
no[i]++;
}
break;
}
for (int i = 0; i < 26; i++) {
for (int j = 0; j < no[i]; j++) {
cout << (char)('a' + i);
}
}
cout << '\n';
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
A schoolboy Petya studies square equations. The equations that are included in the school curriculum, usually look simple:
x2 + 2bx + c = 0 where b, c are natural numbers.
Petya noticed that some equations have two real roots, some of them have only one root and some equations don't have real roots at all. Moreover it turned out that several different square equations can have a common root.
Petya is interested in how many different real roots have all the equations of the type described above for all the possible pairs of numbers b and c such that 1 ≤ b ≤ n, 1 ≤ c ≤ m. Help Petya find that number.
Input
The single line contains two integers n and m. (1 ≤ n, m ≤ 5000000).
Output
Print a single number which is the number of real roots of the described set of equations.
Examples
Input
3 3
Output
12
Input
1 2
Output
1
Note
In the second test from the statement the following equations are analysed:
b = 1, c = 1: x2 + 2x + 1 = 0; The root is x = - 1
b = 1, c = 2: x2 + 2x + 2 = 0; No roots
Overall there's one root
In the second test the following equations are analysed:
b = 1, c = 1: x2 + 2x + 1 = 0; The root is x = - 1
b = 1, c = 2: x2 + 2x + 2 = 0; No roots
b = 1, c = 3: x2 + 2x + 3 = 0; No roots
b = 2, c = 1: x2 + 4x + 1 = 0; The roots are <image>
b = 2, c = 2: x2 + 4x + 2 = 0; The roots are <image>
b = 2, c = 3: x2 + 4x + 3 = 0; The roots are x1 = - 3, x2 = - 1
b = 3, c = 1: x2 + 6x + 1 = 0; The roots are <image>
b = 3, c = 2: x2 + 6x + 2 = 0; The roots are <image>
b = 3, c = 3: x2 + 6x + 3 = 0; The roots are <image> Overall there are 13 roots and as the root - 1 is repeated twice, that means there are 12 different roots.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline int countbit(T n) {
return (n == 0) ? 0 : (1 + countbit(n & (n - 1)));
}
template <class T>
inline T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
const double EPS = 1e-9;
const double PI = acos(-1.0);
int cnt[10000010];
int main(void) {
memset(cnt, 0, sizeof(cnt));
long long n, m;
cin >> n >> m;
long long total = 0;
for (long long i = 1; i <= n; i++) {
long long l;
if (((i) * (i)) > m)
l = ceil(sqrt(((i) * (i)) - m));
else
l = 0;
long long r = floor(sqrt(((i) * (i)) - 1));
total += (min(((i) * (i)), m) - (i - l)) * 2LL;
if (r >= l) {
cnt[i - r - 1]--;
cnt[i - l]++;
cnt[i + l - 1]--;
cnt[i + r]++;
}
}
int aux = 0;
for (int i = 10000000; i >= 0; i--) {
aux += cnt[i];
if (aux > 0) total++;
}
cout << total << endl;
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Find the diameter of a convex polygon g. In other words, find a pair of points that have maximum distance between them.
Constraints
* 3 ≤ n ≤ 80000
* -100 ≤ xi, yi ≤ 100
* No point in the g will occur more than once.
Input
n
x1 y1
x2 y2
:
xn yn
The first integer n is the number of points in g.
In the following lines, the coordinate of the i-th point pi is given by two real numbers xi and yi. The coordinates of points are given in the order of counter-clockwise visit of them. Each value is a real number with at most 6 digits after the decimal point.
Output
Print the diameter of g in a line. The output values should be in a decimal fraction with an error less than 0.000001.
Examples
Input
3
0.0 0.0
4.0 0.0
2.0 2.0
Output
4.00
Input
4
0.0 0.0
1.0 0.0
1.0 1.0
0.0 1.0
Output
1.414213562373
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
const int N = 2e5+100;
const double eps = (1e-10);
//点
struct Point{
double x,y;
Point(double _x=0,double _y=0):x(_x),y(_y){}
Point operator + (Point p){return Point(x+p.x,y+p.y);}
Point operator - (Point p){return Point(x-p.x,y-p.y);}
Point operator * (double a){return Point(a*x,a*y);}
Point operator / (double a){return Point(x/a,y/a);}
double norm(){return x*x+y*y;}//模的平方
double ABS() {return sqrt(norm());}//模
};
//线段
struct Segment{
Point p1,p2;
};
double dot(Point a,Point b){
return a.x*b.x+a.y*b.y;
}
double cross(Point a,Point b){
return a.x*b.y-a.y*b.x;
}
vector<Point> G;
//旋转卡壳计算凸包直径
double Diameter(vector<Point> G){
double ans=0;
int n=G.size();
for(int i=0,k=0;i<n;i++){
while((G[i]-G[k]).norm()<(G[i]-G[(k+1)%n]).norm()) k=(k+1)%n;
ans=max(ans,(G[i]-G[k]).ABS());
}
return ans;
}
int main(){
int n;scanf("%d",&n);
double x,y;
for(int i=1;i<=n;i++){
scanf("%lf %lf",&x,&y);
G.push_back({x,y});
}
double ans=Diameter(G);
printf("%.10lf\n",ans);
return 0;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
The Cybernetics Failures (CF) organisation made a prototype of a bomb technician robot. To find the possible problems it was decided to carry out a series of tests. At the beginning of each test the robot prototype will be placed in cell (x0, y0) of a rectangular squared field of size x × y, after that a mine will be installed into one of the squares of the field. It is supposed to conduct exactly x·y tests, each time a mine is installed into a square that has never been used before. The starting cell of the robot always remains the same.
After placing the objects on the field the robot will have to run a sequence of commands given by string s, consisting only of characters 'L', 'R', 'U', 'D'. These commands tell the robot to move one square to the left, to the right, up or down, or stay idle if moving in the given direction is impossible. As soon as the robot fulfills all the sequence of commands, it will blow up due to a bug in the code. But if at some moment of time the robot is at the same square with the mine, it will also blow up, but not due to a bug in the code.
Moving to the left decreases coordinate y, and moving to the right increases it. Similarly, moving up decreases the x coordinate, and moving down increases it.
The tests can go on for very long, so your task is to predict their results. For each k from 0 to length(s) your task is to find in how many tests the robot will run exactly k commands before it blows up.
Input
The first line of the input contains four integers x, y, x0, y0 (1 ≤ x, y ≤ 500, 1 ≤ x0 ≤ x, 1 ≤ y0 ≤ y) — the sizes of the field and the starting coordinates of the robot. The coordinate axis X is directed downwards and axis Y is directed to the right.
The second line contains a sequence of commands s, which should be fulfilled by the robot. It has length from 1 to 100 000 characters and only consists of characters 'L', 'R', 'U', 'D'.
Output
Print the sequence consisting of (length(s) + 1) numbers. On the k-th position, starting with zero, print the number of tests where the robot will run exactly k commands before it blows up.
Examples
Input
3 4 2 2
UURDRDRL
Output
1 1 0 1 1 1 1 0 6
Input
2 2 2 2
ULD
Output
1 1 1 1
Note
In the first sample, if we exclude the probable impact of the mines, the robot's route will look like that: <image>.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
bool used[501][501];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m, x, y;
cin >> n >> m >> x >> y;
string s;
cin >> s;
int q = 0;
for (int i = 0; i < s.length(); ++i) {
if (!used[x][y]) {
cout << 1 << " ";
++q;
} else
cout << 0 << " ";
used[x][y] = true;
if (s[i] == 'U') --x;
if (s[i] == 'D') ++x;
if (s[i] == 'L') --y;
if (s[i] == 'R') ++y;
if (x == 0) ++x;
if (x == n + 1) --x;
if (y == 0) ++y;
if (y == m + 1) --y;
}
cout << n * m - q;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
Yaroslav has an array that consists of n integers. In one second Yaroslav can swap two neighboring array elements. Now Yaroslav is wondering if he can obtain an array where any two neighboring elements would be distinct in a finite time.
Help Yaroslav.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the number of elements in the array. The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 1000) — the array elements.
Output
In the single line print "YES" (without the quotes) if Yaroslav can obtain the array he needs, and "NO" (without the quotes) otherwise.
Examples
Input
1
1
Output
YES
Input
3
1 1 2
Output
YES
Input
4
7 7 7 7
Output
NO
Note
In the first sample the initial array fits well.
In the second sample Yaroslav can get array: 1, 2, 1. He can swap the last and the second last elements to obtain it.
In the third sample Yarosav can't get the array he needs.
### Response
```cpp
#include <bits/stdc++.h>
int data[1001];
int main() {
int n;
int tmp;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &tmp);
tmp--;
data[tmp]++;
}
if (n % 2 == 1) {
tmp = n / 2 + 1;
} else {
tmp = n / 2;
}
for (int i = 0; i < 1000; i++) {
if (data[i] > tmp) {
printf("NO");
return 0;
}
}
printf("YES");
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
The sequence of m integers is called the permutation if it contains all integers from 1 to m exactly once. The number m is called the length of the permutation.
Dreamoon has two permutations p_1 and p_2 of non-zero lengths l_1 and l_2.
Now Dreamoon concatenates these two permutations into another sequence a of length l_1 + l_2. First l_1 elements of a is the permutation p_1 and next l_2 elements of a is the permutation p_2.
You are given the sequence a, and you need to find two permutations p_1 and p_2. If there are several possible ways to restore them, you should find all of them. (Note that it is also possible that there will be no ways.)
Input
The first line contains an integer t (1 ≤ t ≤ 10 000) denoting the number of test cases in the input.
Each test case contains two lines. The first line contains one integer n (2 ≤ n ≤ 200 000): the length of a. The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ n-1).
The total sum of n is less than 200 000.
Output
For each test case, the first line of output should contain one integer k: the number of ways to divide a into permutations p_1 and p_2.
Each of the next k lines should contain two integers l_1 and l_2 (1 ≤ l_1, l_2 ≤ n, l_1 + l_2 = n), denoting, that it is possible to divide a into two permutations of length l_1 and l_2 (p_1 is the first l_1 elements of a, and p_2 is the last l_2 elements of a). You can print solutions in any order.
Example
Input
6
5
1 4 3 2 1
6
2 4 1 3 2 1
4
2 1 1 3
4
1 3 3 1
12
2 1 3 4 5 6 7 8 9 1 10 2
3
1 1 1
Output
2
1 4
4 1
1
4 2
0
0
1
2 10
0
Note
In the first example, two possible ways to divide a into permutations are \{1\} + \{4, 3, 2, 1\} and \{1,4,3,2\} + \{1\}.
In the second example, the only way to divide a into permutations is \{2,4,1,3\} + \{2,1\}.
In the third example, there are no possible ways.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
char c = getchar();
int x = 0;
bool op = 0;
while (!isdigit(c)) op |= (c == '-'), c = getchar();
while (isdigit(c)) x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
return op ? -x : x;
}
const int N = 200010;
int t, n;
int a[N], f[N], tot[N];
bool ans[N], vis[N];
void init() {
for (int i = 1; i <= n; i++) {
tot[i] = 1;
f[i] = i;
}
return;
}
int find(int x) {
if (f[x] == x) {
return x;
}
return f[x] = find(f[x]);
}
void unionn(int x, int y) {
int fx = find(x), fy = find(y);
if (fx != fy) {
f[fy] = fx;
tot[fx] += tot[fy];
}
return;
}
int main() {
t = read();
while (t--) {
memset(ans, false, sizeof(ans));
n = read();
for (int i = 1; i <= n; i++) {
a[i] = read();
}
bool flag = false;
init();
for (int i = 1; i <= n; i++) {
if (a[i] == 1)
flag = true;
else
unionn(a[i], a[i] - 1);
if (flag == true && tot[find(1)] == i) ans[i] = true;
}
init();
flag = false;
int cnt = 0;
for (int i = n; i >= 1; i--) {
if (a[i] == 1)
flag = true;
else
unionn(a[i], a[i] - 1);
if (flag == false || tot[find(1)] != n - i + 1) ans[i - 1] = false;
}
for (int i = 1; i <= n; i++) {
if (ans[i] == true) cnt++;
}
printf("%d\n", cnt);
for (int i = 1; i <= n; i++) {
if (ans[i] == true) {
printf("%d %d\n", i, n - i);
}
}
}
return 0;
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
Valera is a little boy. Yesterday he got a huge Math hometask at school, so Valera didn't have enough time to properly learn the English alphabet for his English lesson. Unfortunately, the English teacher decided to have a test on alphabet today. At the test Valera got a square piece of squared paper. The length of the side equals n squares (n is an odd number) and each unit square contains some small letter of the English alphabet.
Valera needs to know if the letters written on the square piece of paper form letter "X". Valera's teacher thinks that the letters on the piece of paper form an "X", if:
* on both diagonals of the square paper all letters are the same;
* all other squares of the paper (they are not on the diagonals) contain the same letter that is different from the letters on the diagonals.
Help Valera, write the program that completes the described task for him.
Input
The first line contains integer n (3 ≤ n < 300; n is odd). Each of the next n lines contains n small English letters — the description of Valera's paper.
Output
Print string "YES", if the letters on the paper form letter "X". Otherwise, print string "NO". Print the strings without quotes.
Examples
Input
5
xooox
oxoxo
soxoo
oxoxo
xooox
Output
NO
Input
3
wsw
sws
wsw
Output
YES
Input
3
xpx
pxp
xpe
Output
NO
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string A[301];
for (int i = 0; i < n; i++) {
cin >> A[i];
}
char a = A[0][0];
char b = A[1][0];
if (a == b) {
cout << "NO" << endl;
return 0;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if ((i == j) || (i == n - 1 - j)) {
if (A[i][j] != a) {
cout << "NO" << endl;
return 0;
}
} else {
if (A[i][j] != b) {
cout << "NO" << endl;
return 0;
}
}
}
}
cout << "YES" << endl;
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
A little girl loves problems on bitwise operations very much. Here's one of them.
You are given two integers l and r. Let's consider the values of <image> for all pairs of integers a and b (l ≤ a ≤ b ≤ r). Your task is to find the maximum value among all considered ones.
Expression <image> means applying bitwise excluding or operation to integers x and y. The given operation exists in all modern programming languages, for example, in languages C++ and Java it is represented as "^", in Pascal — as "xor".
Input
The single line contains space-separated integers l and r (1 ≤ l ≤ r ≤ 1018).
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
In a single line print a single integer — the maximum value of <image> for all pairs of integers a, b (l ≤ a ≤ b ≤ r).
Examples
Input
1 2
Output
3
Input
8 16
Output
31
Input
1 1
Output
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int A, B;
cin >> A >> B;
long long int num = 1;
while (A / num != B / num) {
num *= 2;
}
cout << num - 1 << "\n";
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
Yura has a team of k developers and a list of n tasks numbered from 1 to n. Yura is going to choose some tasks to be done this week. Due to strange Looksery habits the numbers of chosen tasks should be a segment of consecutive integers containing no less than 2 numbers, i. e. a sequence of form l, l + 1, ..., r for some 1 ≤ l < r ≤ n.
Every task i has an integer number ai associated with it denoting how many man-hours are required to complete the i-th task. Developers are not self-confident at all, and they are actually afraid of difficult tasks. Knowing that, Yura decided to pick up a hardest task (the one that takes the biggest number of man-hours to be completed, among several hardest tasks with same difficulty level he chooses arbitrary one) and complete it on his own. So, if tasks with numbers [l, r] are chosen then the developers are left with r - l tasks to be done by themselves.
Every developer can spend any integer amount of hours over any task, but when they are done with the whole assignment there should be exactly ai man-hours spent over the i-th task.
The last, but not the least problem with developers is that one gets angry if he works more than another developer. A set of tasks [l, r] is considered good if it is possible to find such a distribution of work that allows to complete all the tasks and to have every developer working for the same amount of time (amount of work performed by Yura doesn't matter for other workers as well as for him).
For example, let's suppose that Yura have chosen tasks with following difficulties: a = [1, 2, 3, 4], and he has three developers in his disposal. He takes the hardest fourth task to finish by himself, and the developers are left with tasks with difficulties [1, 2, 3]. If the first one spends an hour on the first task and an hour on the third one, the second developer spends two hours on the second task and the third developer spends two hours on the third task, then they are done, since every developer worked exactly for two hours and every task has been worked over for the required amount of time. As another example, if the first task required two hours instead of one to be completed then it would be impossible to assign the tasks in a way described above.
Besides work, Yura is fond of problem solving. He wonders how many pairs (l, r) (1 ≤ l < r ≤ n) exists such that a segment [l, r] is good? Yura has already solved this problem, but he has no time to write the code. Please, help Yura and implement the solution for this problem.
Input
The first line of input contains two positive integers: n and k (1 ≤ n ≤ 300 000, 1 ≤ k ≤ 1 000 000), the number of tasks in the list and the number of developers in Yura's disposal.
The second line contains n integers ai (1 ≤ ai ≤ 109).
Output
Output a single integer — the number of pairs (l, r) satisfying the conditions from the statement.
Examples
Input
4 3
1 2 3 4
Output
3
Input
4 2
4 4 7 4
Output
6
Note
In the first sample there are three good segments:
1. [1;3] — the hardest task requires 3 man-hours, so there are tasks left that require 1 and 2 man-hours. A solution is to make first developer work on the first task for an hour, while second and third developers work on the second task. Each developer works exactly one hour.
2. [1;4] — the hardest task requires 4 man-hours, so there are tasks left that require 1, 2 and 3 man-hours. If the first developer spends an hour on the first task and an hour on the third one, the second developer spends two hours on the second task and the third developer spends two hours on the third task, then they are done, since every developer worked exactly for two hours.
3. [3;4] — the hardest task requires 4 man-hours, so there is only one task left that requires 3 man-hours. A solution is to make each developer work for an hour.
### Response
```cpp
#include <bits/stdc++.h>
const int INF = 1e9;
const long long lINF = 1e18;
const double EPS = 1e-12;
using namespace std;
const int N = 3e5 + 300, M = 1e6 + 100;
int n, k;
int a[N], _left[N], _right[N];
int sum[N];
vector<pair<int, int> > magic[M];
long long ans = 0;
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
sum[i + 1] = (sum[i] + a[i]) % k;
}
vector<int> v;
for (int i = 0; i < n; i++) {
while (v.size() && a[v.back()] < a[i]) {
v.pop_back();
}
if (v.size()) {
_left[i] = v.back();
} else {
_left[i] = -1;
}
v.push_back(i);
}
v.clear();
for (int i = n - 1; i >= 0; i--) {
while (v.size() && a[v.back()] <= a[i]) {
v.pop_back();
}
if (v.size()) {
_right[i] = v.back();
} else {
_right[i] = n;
}
v.push_back(i);
}
v.clear();
v.push_back(-1);
for (int i = 0; i < n; i++) {
while (v.size() > 1 && a[v.back()] < a[i]) {
v.pop_back();
}
v.push_back(i);
magic[sum[i]].emplace_back(i, 1);
if (_right[i] - i <= i - _left[i])
for (int j = i; j < n && a[j] <= a[i]; j++) {
int cc = 0;
int want = (sum[j + 1] - a[i] % k + k) % k;
while (magic[want].size() > 0 &&
magic[want].back().first > v[v.size() - 2]) {
cc += magic[want].back().second;
magic[want].pop_back();
}
ans += cc;
magic[want].emplace_back(i, cc);
}
}
for (int i = 0; i < k; i++) {
magic[i].clear();
}
v.clear();
v.push_back(n);
for (int i = n - 1; i >= 0; i--) {
while (v.size() > 1 && a[v.back()] <= a[i]) {
v.pop_back();
}
v.push_back(i);
magic[sum[i + 1]].emplace_back(i, 1);
if (_right[i] - i > i - _left[i])
for (int j = i; j >= 0 && (i == j || a[j] < a[i]); j--) {
int cc = 0;
int want = (sum[j] + a[i] % k + k) % k;
while (magic[want].size() > 0 &&
magic[want].back().first < v[v.size() - 2]) {
cc += magic[want].back().second;
magic[want].pop_back();
}
ans += cc;
magic[want].emplace_back(i, cc);
}
}
printf("%lld", ans - n);
return 0;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
You must have heard of the two brothers dreaming of ruling the world. With all their previous plans failed, this time they decided to cooperate with each other in order to rule the world.
As you know there are n countries in the world. These countries are connected by n - 1 directed roads. If you don't consider direction of the roads there is a unique path between every pair of countries in the world, passing through each road at most once.
Each of the brothers wants to establish his reign in some country, then it's possible for him to control the countries that can be reached from his country using directed roads.
The brothers can rule the world if there exists at most two countries for brothers to choose (and establish their reign in these countries) so that any other country is under control of at least one of them. In order to make this possible they want to change the direction of minimum number of roads. Your task is to calculate this minimum number of roads.
Input
The first line of input contains an integer n (1 ≤ n ≤ 3000). Each of the next n - 1 lines contains two space-separated integers ai and bi (1 ≤ ai, bi ≤ n; ai ≠ bi) saying there is a road from country ai to country bi.
Consider that countries are numbered from 1 to n. It's guaranteed that if you don't consider direction of the roads there is a unique path between every pair of countries in the world, passing through each road at most once.
Output
In the only line of output print the minimum number of roads that their direction should be changed so that the brothers will be able to rule the world.
Examples
Input
4
2 1
3 1
4 1
Output
1
Input
5
2 1
2 3
4 3
4 5
Output
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-5;
const int inf = (1 << 31) - 1;
const int hinf = 1000000000;
const int mod = 1000000007;
const int N = 3030;
int dp[3030][3030];
int dir[3030][3030];
int n;
int head[3030];
int weizhi;
struct node {
int u, v, w, next;
} point[3030 << 1];
void add(int u, int v, int w) {
point[weizhi].u = u;
point[weizhi].v = v;
point[weizhi].w = w;
point[weizhi].next = head[u];
head[u] = weizhi++;
}
void dfs(int now, int par, int dp[N]) {
dp[now] = 0;
for (int k = head[now]; k != -1; k = point[k].next) {
int i = point[k].v;
if (i == par) continue;
dfs(i, now, dp);
dp[now] += dp[i] + point[k].w;
}
}
void DFS(int now, int p, int a, int& ret) {
ret = min(ret, dp[now][now] - dp[now][a]);
for (int k = head[now]; k != -1; k = point[k].next) {
int i = point[k].v;
if (i == p) continue;
DFS(i, now, a, ret);
}
}
int main() {
scanf("%d", &n);
int a, b;
memset((head), -1, sizeof(head));
weizhi = 0;
for (int i = 1; i < n; i++) {
scanf("%d%d", &a, &b);
add(a, b, 0);
add(b, a, 1);
dir[a][b] = 0;
dir[b][a] = 1;
}
memset(dp, 0, sizeof(dp));
if (n == 1) {
cout << 0 << endl;
return 0;
}
for (int i = 1; i <= n; i++) {
dfs(i, -1, dp[i]);
}
int ans = inf;
for (int u = 1; u <= n; u++) {
for (int k = head[u]; k != -1; k = point[k].next) {
int i = point[k].v;
int w = point[k].w;
if (w) continue;
int ret1 = inf;
int ret2 = inf;
DFS(i, u, u, ret1);
DFS(u, i, i, ret2);
ans = min(ans, ret1 + ret2 - 1);
}
}
printf("%d\n", ans);
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
()
Problem Statement
There is a string S. Initially, S is an empty string.
Perform the following processing in order of n.
* Add x_i p_i (=" (" or") ") to the end of S.
After processing, determine if S is a well-balanced string.
"The string is balanced" is defined as follows.
* The empty string is well-balanced.
* For balanced strings a and b, a + b (+ represents a concatenation of strings) is balanced.
* For a balanced string a, "(" + a + ")" is balanced.
Constraints
* 1 ≤ n ≤ 1,000
* 1 ≤ x_i ≤ 10 ^ 6
* p_i is "(" or ")"
Input
Input follows the following format. All given numbers are integers.
n
p_1 x_1
.. ..
p_n x_n
Output
Output "YES" if balanced, otherwise output "NO" on one line.
Examples
Input
3
( 5
) 4
) 1
Output
YES
Input
5
( 2
) 2
( 3
) 1
) 2
Output
YES
Input
2
) 1
( 1
Output
NO
### Response
```cpp
#include<iostream>
#include<algorithm>
using namespace std;
int main(){
string s;
int n;
cin>>n;
int cnt = 0;
bool flg = true;
while(n--){
char p;
int x;
cin>>p>>x;
if(p == '(')cnt += x;
else cnt -= x;
if(cnt < 0){flg = false;break;}
}
if(flg&!cnt)cout<<"YES"<<endl;
else cout<<"NO"<<endl;
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
Japan achieved the second straight victory in the national baseball competition WBC !! A baseball tournament was held at Aizu Gakuen High School as baseball became more popular. In this tournament, a round-robin league match will be held and the ranking will be decided in the following ways.
1. The team with the most wins is ranked high
2. If the number of wins is the same, the team with the fewest losses will be ranked higher.
Create a program that inputs the results of each team and outputs the team names in order from the top team. If there are teams with the same rank, output them in the order of input. However, the number of teams n is an integer from 2 to 10 and the team name t is a single-byte alphabetic character. , 2 for a draw. Also, the team name shall be unique.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
n
score1
score2
::
scoren
The number of teams n (2 ≤ n ≤ 10) is given on the first line, and the scorei of the i-th team is given on the following n lines. Each grade is given in the following format.
t r1 r2 ... rn−1
The team name t (one-character half-width alphabetic character) and the result ri (0, 1, or 2) for each match of t are given separated by blanks.
The number of datasets does not exceed 50.
Output
For each dataset, the team name is output in order from the top team.
Example
Input
6
A 1 0 0 2 0
B 0 0 1 1 0
C 1 1 1 1 1
D 1 0 0 1 2
E 2 0 0 0 0
F 1 1 0 2 1
4
g 1 1 1
h 0 1 2
w 0 0 0
b 0 2 1
0
Output
E
A
B
D
F
C
w
h
b
g
### Response
```cpp
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <functional>
#include <numeric>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <utility>
#include <sstream>
#include <complex>
using namespace std;
#define FOR(i,a,b) for(long long i=(a);i<(b);i++)
#define REP(i,N) for(long long i=0;i<(N);i++)
#define ALL(s) (s).begin(),(s).end()
#define fi first
#define se second
#define PI acos(-1.0)
#define INF 1000000007
#define EPS 1e-10
typedef long long ll;
typedef pair<ll, ll> P;
typedef pair<double, double> PD;
typedef pair<string, ll> PS;
typedef vector<ll> V;
typedef pair<P, char> PC;
vector<PC> table;//??????????????????????????????
int n, co[3], num;
char c;
bool flag(PC a, PC b){
if (a.first.first == b.first.first){
return a.first.second < b.first.second;
}
return a.first.first > b.first.first;
}
int main(){
while (cin >> n&&n){
REP(i, n){
cin >> c;
co[0] = co[1] = 0;
REP(i, n - 1){
cin >> num;
co[num]++;
}
table.push_back(PC(P(co[0], co[1]), c));
}
sort(ALL(table), flag);
REP(i, n){
cout<< table[i].second << endl;
}
table.clear();
}
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
Polycarpus has a finite sequence of opening and closing brackets. In order not to fall asleep in a lecture, Polycarpus is having fun with his sequence. He is able to perform two operations:
* adding any bracket in any position (in the beginning, the end, or between any two existing brackets);
* cyclic shift — moving the last bracket from the end of the sequence to the beginning.
Polycarpus can apply any number of operations to his sequence and adding a cyclic shift in any order. As a result, he wants to get the correct bracket sequence of the minimum possible length. If there are several such sequences, Polycarpus is interested in the lexicographically smallest one. Help him find such a sequence.
Acorrect bracket sequence is a sequence of opening and closing brackets, from which you can get a correct arithmetic expression by adding characters "1" and "+" . Each opening bracket must correspond to a closed one. For example, the sequences "(())()", "()", "(()(()))" are correct and ")(", "(()" and "(()))(" are not.
The sequence a1 a2... an is lexicographically smaller than sequence b1 b2... bn, if there is such number i from 1 to n, thatak = bk for 1 ≤ k < i and ai < bi. Consider that "(" < ")".
Input
The first line contains Polycarpus's sequence consisting of characters "(" and ")". The length of a line is from 1 to 1 000 000.
Output
Print a correct bracket sequence of the minimum length that Polycarpus can obtain by his operations. If there are multiple such sequences, print the lexicographically minimum one.
Examples
Input
()(())
Output
(())()
Input
()(
Output
(())
Note
The sequence in the first example is already correct, but to get the lexicographically minimum answer, you need to perform four cyclic shift operations. In the second example you need to add a closing parenthesis between the second and third brackets and make a cyclic shift. You can first make the shift, and then add the bracket at the end.
### Response
```cpp
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:666777216")
using namespace std;
const int N = 1000007;
char st[N];
int n, sum[N], openCnt[N];
struct segTree {
int T[4 * N];
void build(int v, int tl, int tr, int *sum) {
if (tl == tr) {
T[v] = sum[tl];
return;
}
int tm = (tl + tr) / 2;
build(2 * v, tl, tm, sum);
build(2 * v + 1, tm + 1, tr, sum);
T[v] = min(T[2 * v], T[2 * v + 1]);
}
void update(int v, int tl, int tr, int pos, int val) {
if (tl == tr) {
T[v] = val;
return;
}
int tm = (tl + tr) / 2;
if (pos <= tm)
update(2 * v, tl, tm, pos, val);
else
update(2 * v + 1, tm + 1, tr, pos, val);
T[v] = min(T[2 * v], T[2 * v + 1]);
}
int get(int v, int tl, int tr, int l, int r) {
if (r < l) return N;
if (tl == l && tr == r) return T[v];
int tm = (tl + tr) / 2;
if (r <= tm) return get(2 * v, tl, tm, l, r);
if (l > tm) return get(2 * v + 1, tm + 1, tr, l, r);
return min(get(2 * v, tl, tm, l, tm),
get(2 * v + 1, tm + 1, tr, tm + 1, r));
}
} tree;
inline int get(int l, int r, int *sum) {
if (l > r) return 0;
if (l == 0) return sum[r];
return sum[r] - sum[l - 1];
}
int open[N], close[N];
inline int code(char c) { return c == '(' ? 0 : 1; }
struct SA {
int pos[N], tpos[N], cnt[N], rev[N];
int C[21][N];
void build() {
memset(cnt, 0, sizeof cnt);
for (int i = 0; i < (n); ++i) ++cnt[code(st[i])];
for (int i = 0; i < (n); ++i) {
if (i) cnt[i] += cnt[i - 1];
}
for (int i = n - 1; i >= 0; --i) {
pos[i] = --cnt[code(st[i])];
}
for (int i = 0; i < (n); ++i) {
C[0][i] = code(st[i]);
}
for (int h = 1, lev = 0; h < n; h <<= 1, ++lev) {
for (int i = 0; i < (n); ++i) {
tpos[i] = pos[(i + h) % n];
}
memset(cnt, 0, sizeof cnt);
for (int i = 0; i < (n); ++i) ++cnt[C[lev][i]];
for (int i = 0; i < (n); ++i) {
if (i) cnt[i] += cnt[i - 1];
}
for (int i = 0; i < (n); ++i) {
rev[tpos[i]] = i;
}
for (int i = n - 1; i >= 0; --i) {
int ind = rev[i];
pos[ind] = --cnt[C[lev][ind]];
}
for (int i = 0; i < (n); ++i) {
rev[pos[i]] = i;
}
C[lev + 1][rev[0]] = 0;
for (int i = 1, cur = 0; i < n; ++i) {
if (C[lev][rev[i - 1]] != C[lev][rev[i]] ||
C[lev][(rev[i - 1] + h) % n] != C[lev][(rev[i] + h) % n])
++cur;
C[lev + 1][rev[i]] = cur;
}
}
}
} sa;
bool checkOpen(int i, int j) {
if (i < j) return get(i, j, openCnt) == j - i + 1;
return get(i, n - 1, openCnt) + get(0, j, openCnt) ==
n - 1 - i + 1 + j - 0 + 1;
}
int cmp(int i, int j, int len) {
for (int h = 19; h >= 0; --h) {
if ((1 << h) > len) continue;
if (sa.C[h][i] < sa.C[h][j]) return -1;
if (sa.C[h][i] > sa.C[h][j]) return 1;
i = (i + (1 << h)) % n;
j = (j + (1 << h)) % n;
}
return 0;
}
bool compare(int i, int j) {
int op1 = open[i] - min(open[i], open[j]);
int op2 = open[j] - min(open[i], open[j]);
int cl1 = close[i];
int cl2 = close[j];
if (op1 != 0) {
if (!checkOpen(j, (j + op1) % n)) return true;
j = (j + op1) % n;
}
if (op2 != 0) {
if (!checkOpen(i, (i + op2) % n)) return false;
i = (i + op2) % n;
}
int res = cmp(i, j, n - max(op1, op2));
if (res == -1) return true;
if (res == 1) return false;
return cl1 <= cl2;
}
void solve() {
scanf("%s", st);
n = strlen(st);
for (int i = 0; i < (n); ++i) {
int psum = (i ? sum[i - 1] : 0);
if (st[i] == '(')
sum[i] = psum + 1;
else
sum[i] = psum - 1;
int popen = (i ? openCnt[i - 1] : 0);
if (st[i] == '(')
openCnt[i] = popen + 1;
else
openCnt[i] = popen;
}
tree.build(1, 0, n - 1, sum);
int totalBal = sum[n - 1];
for (int i = 0; i < (n); ++i) {
int min1 = tree.get(1, 0, n - 1, i, n - 1) - get(0, i - 1, sum);
int min2 = tree.get(1, 0, n - 1, 0, i - 1) + get(i, n - 1, sum);
int mini = min(min1, min2);
if (mini >= 0) {
close[i] = totalBal;
} else {
open[i] = -mini;
if (totalBal + open[i] < 0)
open[i] += -(totalBal + open[i]);
else
close[i] = totalBal + open[i];
}
}
int minAdd = N + N;
for (int i = 0; i < (n); ++i) {
minAdd = min(minAdd, open[i] + close[i]);
}
sa.build();
int best = -1;
for (int i = 0; i < (n); ++i) {
if (open[i] + close[i] != minAdd) continue;
if (best == -1 || compare(i, best)) {
best = i;
}
}
for (int i = 0; i < (open[best]); ++i) putchar('(');
for (int i = best; i < n; ++i) {
putchar(st[i]);
}
for (int i = 0; i < best; ++i) {
putchar(st[i]);
}
for (int i = 0; i < (close[best]); ++i) putchar(')');
}
int rd() { return (((long long)rand() << 16) ^ rand()) % 1000000000; }
void testGen() {
FILE *f = fopen("input.txt", "w");
fclose(f);
}
int main() {
cerr << fixed;
cerr.precision(5);
solve();
return 0;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
Adilbek's house is located on a street which can be represented as the OX axis. This street is really dark, so Adilbek wants to install some post lamps to illuminate it. Street has n positions to install lamps, they correspond to the integer numbers from 0 to n - 1 on the OX axis. However, some positions are blocked and no post lamp can be placed there.
There are post lamps of different types which differ only by their power. When placed in position x, post lamp of power l illuminates the segment [x; x + l]. The power of each post lamp is always a positive integer number.
The post lamp shop provides an infinite amount of lamps of each type from power 1 to power k. Though each customer is only allowed to order post lamps of exactly one type. Post lamps of power l cost a_l each.
What is the minimal total cost of the post lamps of exactly one type Adilbek can buy to illuminate the entire segment [0; n] of the street? If some lamps illuminate any other segment of the street, Adilbek does not care, so, for example, he may place a lamp of power 3 in position n - 1 (even though its illumination zone doesn't completely belong to segment [0; n]).
Input
The first line contains three integer numbers n, m and k (1 ≤ k ≤ n ≤ 10^6, 0 ≤ m ≤ n) — the length of the segment of the street Adilbek wants to illuminate, the number of the blocked positions and the maximum power of the post lamp available.
The second line contains m integer numbers s_1, s_2, ..., s_m (0 ≤ s_1 < s_2 < ... s_m < n) — the blocked positions.
The third line contains k integer numbers a_1, a_2, ..., a_k (1 ≤ a_i ≤ 10^6) — the costs of the post lamps.
Output
Print the minimal total cost of the post lamps of exactly one type Adilbek can buy to illuminate the entire segment [0; n] of the street.
If illumintaing the entire segment [0; n] is impossible, print -1.
Examples
Input
6 2 3
1 3
1 2 3
Output
6
Input
4 3 4
1 2 3
1 10 100 1000
Output
1000
Input
5 1 5
0
3 3 3 3 3
Output
-1
Input
7 4 3
2 4 5 6
3 14 15
Output
-1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
int n, m, k;
long long ans;
bool e[1000001];
int pre[1000001];
struct light {
int l, cost;
double c;
} s[1000001];
bool cmp(light a, light b) { return a.c > b.c; }
int dfs(int p, int sum, int l) {
int np = p + l;
if (np >= n) return sum + 1;
np = pre[np];
if (np == p)
return -1;
else
return dfs(np, sum + 1, l);
}
int main() {
scanf("%d%d%d", &n, &m, &k);
ans = -1;
memset(e, false, sizeof(e));
for (int i = 0; i < m; i++) {
int a;
scanf("%d", &a);
e[a] = true;
}
for (int i = 1; i < n; i++) {
if (e[i])
pre[i] = pre[i - 1];
else
pre[i] = i;
}
for (int i = 0; i < k; i++) {
s[i].l = i + 1;
scanf("%d", &s[i].cost);
s[i].c = (double)((double)s[i].l / (double)s[i].cost);
}
if (e[0]) {
printf("-1\n");
return 0;
}
for (int i = 0; i < k; i++) {
int t = dfs(0, 0, s[i].l);
if (t == -1) continue;
long long tt = (long long)((long long)s[i].cost * (long long)t);
if (ans == -1) {
ans = tt;
} else {
ans = min(ans, tt);
}
}
if (ans != -1)
printf("%I64d\n", ans);
else
printf("-1\n");
return 0;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
Welcome! Everything is fine.
You have arrived in The Medium Place, the place between The Good Place and The Bad Place. You are assigned a task that will either make people happier or torture them for eternity.
You have a list of k pairs of people who have arrived in a new inhabited neighborhood. You need to assign each of the 2k people into one of the 2k houses. Each person will be the resident of exactly one house, and each house will have exactly one resident.
Of course, in the neighborhood, it is possible to visit friends. There are 2k - 1 roads, each of which connects two houses. It takes some time to traverse a road. We will specify the amount of time it takes in the input. The neighborhood is designed in such a way that from anyone's house, there is exactly one sequence of distinct roads you can take to any other house. In other words, the graph with the houses as vertices and the roads as edges is a tree.
The truth is, these k pairs of people are actually soulmates. We index them from 1 to k. We denote by f(i) the amount of time it takes for the i-th pair of soulmates to go to each other's houses.
As we have said before, you will need to assign each of the 2k people into one of the 2k houses. You have two missions, one from the entities in The Good Place and one from the entities of The Bad Place. Here they are:
* The first mission, from The Good Place, is to assign the people into the houses such that the sum of f(i) over all pairs i is minimized. Let's define this minimized sum as G. This makes sure that soulmates can easily and efficiently visit each other;
* The second mission, from The Bad Place, is to assign the people into the houses such that the sum of f(i) over all pairs i is maximized. Let's define this maximized sum as B. This makes sure that soulmates will have a difficult time to visit each other.
What are the values of G and B?
Input
The first line of input contains a single integer t (1 ≤ t ≤ 500) denoting the number of test cases. The next lines contain descriptions of the test cases.
The first line of each test case contains a single integer k denoting the number of pairs of people (1 ≤ k ≤ 10^5). The next 2k - 1 lines describe the roads; the i-th of them contains three space-separated integers a_i, b_i, t_i which means that the i-th road connects the a_i-th and b_i-th houses with a road that takes t_i units of time to traverse (1 ≤ a_i, b_i ≤ 2k, a_i ≠ b_i, 1 ≤ t_i ≤ 10^6). It is guaranteed that the given roads define a tree structure.
It is guaranteed that the sum of the k in a single file is at most 3 ⋅ 10^5.
Output
For each test case, output a single line containing two space-separated integers G and B.
Example
Input
2
3
1 2 3
3 2 4
2 4 3
4 5 6
5 6 5
2
1 2 1
1 3 2
1 4 3
Output
15 33
6 6
Note
For the sample test case, we have a minimum sum equal to G = 15. One way this can be achieved is with the following assignment:
* The first pair of people get assigned to houses 5 and 6, giving us f(1) = 5;
* The second pair of people get assigned to houses 1 and 4, giving us f(2) = 6;
* The third pair of people get assigned to houses 3 and 2, giving us f(3) = 4.
Note that the sum of the f(i) is 5 + 6 + 4 = 15.
We also have a maximum sum equal to B = 33. One way this can be achieved is with the following assignment:
* The first pair of people get assigned to houses 1 and 4, giving us f(1) = 6;
* The second pair of people get assigned to houses 6 and 2, giving us f(2) = 14;
* The third pair of people get assigned to houses 3 and 5, giving us f(3) = 13.
Note that the sum of the f(i) is 6 + 14 + 13 = 33.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef int (*itoi)(int);
typedef int (*iitoi)(int, int);
typedef int (*iiitoi)(int, int, int);
typedef ll (*ltol)(ll);
typedef ll (*lltol)(ll, ll);
typedef ll (*llltol)(ll, ll, ll);
const long double PI = acos(0) * 2;
const int INF = 0x3f2f1f0f;
const ll LINF = 1ll * INF * INF;
int X4[] = {-1, 0, 1, 0}, Y4[] = {0, -1, 0, 1};
int X8[] = {-1, -1, -1, 0, 1, 1, 1, 0}, Y8[] = {-1, 0, 1, 1, 1, 0, -1, -1};
template <typename T>
inline bool uax(T& a, T b) {
return a < b ? (a = b, 1) : 0;
}
template <typename T>
inline bool uin(T& a, T b) {
return a > b ? (a = b, 1) : 0;
}
template <typename T1, typename T2>
istream& operator>>(istream& is, pair<T1, T2>& p) {
return is >> p.first >> p.second;
}
template <typename T1, typename T2>
ostream& operator<<(ostream& os, const pair<T1, T2>& p) {
return os << '(' << p.first << ", " << p.second << ")";
}
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
for (int i = 0; i < (int)v.size(); i++) {
os << v[i];
if (i + 1 < (int)v.size()) os << ' ';
}
return os;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout << std::setprecision(10);
cout << fixed;
int q;
cin >> q;
while (q--) {
int n;
cin >> n;
n *= 2;
vector<vector<pair<int, ll>>> ed(n + 1);
for (int _i = 0; _i < (n - 1); _i++) {
int a, b;
ll w;
cin >> a >> b >> w;
ed[a].emplace_back(b, w);
ed[b].emplace_back(a, w);
}
vector<int> parent(n + 1, -1);
vector<ll> pcost(n + 1, 0);
vector<int> qu(1, 1);
parent[1] = 0;
for (int f = 0; f < (int)qu.size(); f++) {
int a = qu[f];
for (auto [b, w] : ed[a]) {
if (parent[b] == -1) {
parent[b] = a;
pcost[b] = w;
qu.push_back(b);
}
}
}
vector<int> size(n + 1, 1);
reverse((qu).begin(), (qu).end());
ll mx = 0, mn = 0;
for (auto a : qu) {
size[parent[a]] += size[a];
mx += pcost[a] * min(size[a], n - size[a]);
mn += pcost[a] * (size[a] & 1);
}
cout << mn << ' ' << mx << endl;
}
return 0;
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
Let's call an array good if there is an element in the array that equals to the sum of all other elements. For example, the array a=[1, 3, 3, 7] is good because there is the element a_4=7 which equals to the sum 1 + 3 + 3.
You are given an array a consisting of n integers. Your task is to print all indices j of this array such that after removing the j-th element from the array it will be good (let's call such indices nice).
For example, if a=[8, 3, 5, 2], the nice indices are 1 and 4:
* if you remove a_1, the array will look like [3, 5, 2] and it is good;
* if you remove a_4, the array will look like [8, 3, 5] and it is good.
You have to consider all removals independently, i. e. remove the element, check if the resulting array is good, and return the element into the array.
Input
The first line of the input contains one integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in the array a.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^6) — elements of the array a.
Output
In the first line print one integer k — the number of indices j of the array a such that after removing the j-th element from the array it will be good (i.e. print the number of the nice indices).
In the second line print k distinct integers j_1, j_2, ..., j_k in any order — nice indices of the array a.
If there are no such indices in the array a, just print 0 in the first line and leave the second line empty or do not print it at all.
Examples
Input
5
2 5 1 2 2
Output
3
4 1 5
Input
4
8 3 5 2
Output
2
1 4
Input
5
2 1 2 4 3
Output
0
Note
In the first example you can remove any element with the value 2 so the array will look like [5, 1, 2, 2]. The sum of this array is 10 and there is an element equals to the sum of remaining elements (5 = 1 + 2 + 2).
In the second example you can remove 8 so the array will look like [3, 5, 2]. The sum of this array is 10 and there is an element equals to the sum of remaining elements (5 = 3 + 2). You can also remove 2 so the array will look like [8, 3, 5]. The sum of this array is 16 and there is an element equals to the sum of remaining elements (8 = 3 + 5).
In the third example you cannot make the given array good by removing exactly one element.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using vi = vector<int>;
using ll = long long;
using ull = unsigned long long;
using pii = pair<int, int>;
using vll = vector<ll>;
using pll = pair<ll, ll>;
using vvi = vector<vi>;
constexpr int mod = 1000000007;
constexpr int inf = 0x3f3f3f3f;
inline ll powmod(ll a, ll b) {
ll res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
}
return res;
}
int main() {
int n;
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
vll v(n);
unordered_map<long long, int> freq;
for (auto& x : v) cin >> x;
for (auto& x : v) freq[x]++;
long long soma =
accumulate((v).begin(), (v).end(), 0ll, [](ll a, ll b) { return a + b; });
vi good;
for (int i = 0; i < n; ++i) {
ll x = v[i];
long long rem = soma - x;
if (rem % 2) continue;
long long want = rem / 2;
if (want == x) {
if (freq[want] > 1) good.push_back(i + 1);
} else {
if (freq[want]) good.push_back(i + 1);
}
}
cout << ((int)(good).size()) << endl;
for (const int& x : good) cout << x << " ";
cout << endl;
}
``` |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.