text
stringlengths 424
69.5k
|
|---|
### Prompt
Construct a Cpp code solution to the problem outlined:
Colonel has n badges. He wants to give one badge to every of his n soldiers. Each badge has a coolness factor, which shows how much it's owner reached. Coolness factor can be increased by one for the cost of one coin.
For every pair of soldiers one of them should get a badge with strictly higher factor than the second one. Exact values of their factors aren't important, they just need to have distinct factors.
Colonel knows, which soldier is supposed to get which badge initially, but there is a problem. Some of badges may have the same factor of coolness. Help him and calculate how much money has to be paid for making all badges have different factors of coolness.
Input
First line of input consists of one integer n (1 ≤ n ≤ 3000).
Next line consists of n integers ai (1 ≤ ai ≤ n), which stand for coolness factor of each badge.
Output
Output single integer — minimum amount of coins the colonel has to pay.
Examples
Input
4
1 3 1 4
Output
1
Input
5
1 2 3 2 5
Output
2
Note
In first sample test we can increase factor of first badge by 1.
In second sample test we can increase factors of the second and the third badge by 1.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MX = (int)1e6 + 17;
const int MOD = (int)1e9 + 7;
const long long LINF = (long long)1e18 + 7;
const int INF = (int)999999999;
inline long long IN() {
long long x = 0, ch = getchar(), f = 1;
while (!isdigit(ch) && (ch != '-') && (ch != EOF)) ch = getchar();
if (ch == '-') {
f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return x * f;
}
inline void OUT(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10)
OUT(x / 10), putchar(x % 10 + '0');
else
putchar(x + '0');
}
int n, x, ans;
int a[3001];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + 1 + n);
for (int i = 2; i <= n; i++) {
if (a[i] <= a[i - 1]) ans += a[i - 1] - a[i] + 1, a[i] = a[i - 1] + 1;
}
cout << ans;
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
We have N points in a two-dimensional plane.
The coordinates of the i-th point (1 \leq i \leq N) are (x_i,y_i).
Let us consider a rectangle whose sides are parallel to the coordinate axes that contains K or more of the N points in its interior.
Here, points on the sides of the rectangle are considered to be in the interior.
Find the minimum possible area of such a rectangle.
Constraints
* 2 \leq K \leq N \leq 50
* -10^9 \leq x_i,y_i \leq 10^9 (1 \leq i \leq N)
* x_i≠x_j (1 \leq i<j \leq N)
* y_i≠y_j (1 \leq i<j \leq N)
* All input values are integers. (Added at 21:50 JST)
Input
Input is given from Standard Input in the following format:
N K
x_1 y_1
:
x_{N} y_{N}
Output
Print the minimum possible area of a rectangle that satisfies the condition.
Examples
Input
4 4
1 4
3 3
6 2
8 1
Output
21
Input
4 2
0 0
1 1
2 2
3 3
Output
1
Input
4 3
-1000000000 -1000000000
1000000000 1000000000
-999999999 999999999
999999999 -999999999
Output
3999999996000000001
### Response
```cpp
#include <bits/stdc++.h>
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define all(x) (x).begin(), (x).end()
using ll = long long;
using namespace std;
template <typename T> using vec = std::vector<T>;
int main() {
int N, K;
cin >> N >> K;
vec<ll> x(N), y(N),xs(N),ys(N);
rep(i, N) cin >> x[i] >> y[i];
xs = x;
ys = y;
sort(all(xs));
sort(all(ys));
ll ans = (1LL << 62);
rep(i, N - 1) for (int j = i + 1; j < N; ++j)
rep(k, N - 1) for (int l = k + 1; l < N; ++l) {
ll xmin = xs[i], xmax = xs[j], ymin = ys[k], ymax = ys[l];
int cnt = 0;
rep(p,N){
if(xmin <= x[p] && x[p] <= xmax && ymin <= y[p] && y[p] <= ymax) ++cnt;
}
if(cnt >= K) ans = min(ans,1LL*(xmax-xmin)*(ymax-ymin));
}
cout << ans << endl;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
You've got an array, consisting of n integers a1, a2, ..., an. Also, you've got m queries, the i-th query is described by two integers li, ri. Numbers li, ri define a subsegment of the original array, that is, the sequence of numbers ali, ali + 1, ali + 2, ..., ari. For each query you should check whether the corresponding segment is a ladder.
A ladder is a sequence of integers b1, b2, ..., bk, such that it first doesn't decrease, then doesn't increase. In other words, there is such integer x (1 ≤ x ≤ k), that the following inequation fulfills: b1 ≤ b2 ≤ ... ≤ bx ≥ bx + 1 ≥ bx + 2... ≥ bk. Note that the non-decreasing and the non-increasing sequences are also considered ladders.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 105) — the number of array elements and the number of queries. The second line contains the sequence of integers a1, a2, ..., an (1 ≤ ai ≤ 109), where number ai stands for the i-th array element.
The following m lines contain the description of the queries. The i-th line contains the description of the i-th query, consisting of two integers li, ri (1 ≤ li ≤ ri ≤ n) — the boundaries of the subsegment of the initial array.
The numbers in the lines are separated by single spaces.
Output
Print m lines, in the i-th line print word "Yes" (without the quotes), if the subsegment that corresponds to the i-th query is the ladder, or word "No" (without the quotes) otherwise.
Examples
Input
8 6
1 2 1 3 3 5 2 1
1 3
2 3
2 4
8 8
1 4
5 8
Output
Yes
Yes
No
Yes
No
Yes
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
template <typename T>
inline T gcd(T a, T b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
template <typename T>
inline T lcm(T a, T b) {
return (a * b) / gcd(a, b);
}
template <typename T>
string toStr(T x) {
stringstream st;
st << x;
string s;
st >> s;
return s;
}
template <class T>
void splitStr(const string &s, vector<T> &out) {
istringstream in(s);
out.clear();
copy(istream_iterator<T>(in), istream_iterator<T>(), back_inserter(out));
}
inline int two(int n) { return 1 << n; }
inline int isOnBit(int n, int b) { return (n >> b) & 1; }
inline void onBit(int &n, int b) { n |= two(b); }
inline void offBit(int &n, int b) { n &= ~two(b); }
inline int lastBit(int n) { return n & (-n); }
inline int cntBit(int n) {
int res = 0;
while (n && ++res) n -= n & (-n);
return res;
}
const int dx4[] = {-1, 0, 1, 0};
const int dy4[] = {0, 1, 0, -1};
const int dx8[] = {-1, 0, 1, 0, -1, -1, 1, 1};
const int dy8[] = {0, 1, 0, -1, -1, 1, -1, 1};
int n, m, x, l, r, a[100000 + 5], incr[100000 + 5], decr[100000 + 5];
void gen() {
incr[n] = n;
decr[n] = n;
for (int i = (n - 1), _b = (1); i >= _b; i--) {
if (a[i] > a[i + 1])
incr[i] = i, decr[i] = decr[i + 1];
else if (a[i] < a[i + 1])
incr[i] = incr[i + 1], decr[i] = i;
else
incr[i] = incr[i + 1], decr[i] = decr[i + 1];
}
}
bool ok(int l, int r) {
if (decr[incr[l]] >= r) return true;
return false;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = (1), _b = (n); i <= _b; i++) scanf("%d", &a[i]);
gen();
for (int _ = 0, _n = (m); _ < _n; _++)
scanf("%d%d", &l, &r), printf("%s\n", ok(l, r) ? "Yes" : "No");
return 0;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
By the age of three Smart Beaver mastered all arithmetic operations and got this summer homework from the amazed teacher:
You are given a sequence of integers a1, a2, ..., an. Your task is to perform on it m consecutive operations of the following type:
1. For given numbers xi and vi assign value vi to element axi.
2. For given numbers li and ri you've got to calculate sum <image>, where f0 = f1 = 1 and at i ≥ 2: fi = fi - 1 + fi - 2.
3. For a group of three numbers li ri di you should increase value ax by di for all x (li ≤ x ≤ ri).
Smart Beaver planned a tour around great Canadian lakes, so he asked you to help him solve the given problem.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 2·105) — the number of integers in the sequence and the number of operations, correspondingly. The second line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 105). Then follow m lines, each describes an operation. Each line starts with an integer ti (1 ≤ ti ≤ 3) — the operation type:
* if ti = 1, then next follow two integers xi vi (1 ≤ xi ≤ n, 0 ≤ vi ≤ 105);
* if ti = 2, then next follow two integers li ri (1 ≤ li ≤ ri ≤ n);
* if ti = 3, then next follow three integers li ri di (1 ≤ li ≤ ri ≤ n, 0 ≤ di ≤ 105).
The input limits for scoring 30 points are (subproblem E1):
* It is guaranteed that n does not exceed 100, m does not exceed 10000 and there will be no queries of the 3-rd type.
The input limits for scoring 70 points are (subproblems E1+E2):
* It is guaranteed that there will be queries of the 1-st and 2-nd type only.
The input limits for scoring 100 points are (subproblems E1+E2+E3):
* No extra limitations.
Output
For each query print the calculated sum modulo 1000000000 (109).
Examples
Input
5 5
1 3 1 2 4
2 1 4
2 1 5
2 2 4
1 3 10
2 1 5
Output
12
32
8
50
Input
5 4
1 3 1 2 4
3 1 4 1
2 2 4
1 2 10
2 1 5
Output
12
45
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000000;
struct Matr {
long long a[2][2];
Matr(long long a00 = 0, long long a01 = 0, long long a10 = 0,
long long a11 = 0) {
a[0][0] = a00 % MOD;
a[0][1] = a01 % MOD;
a[1][0] = a10 % MOD;
a[1][1] = a11 % MOD;
}
};
pair<long long, long long> mulMatr(long long f0, long long f1,
const Matr &matr) {
pair<long long, long long> ans;
ans.first = (matr.a[0][0] * f0 + matr.a[1][0] * f1) % MOD;
ans.second = (matr.a[0][1] * f0 + matr.a[1][1] * f1) % MOD;
return ans;
}
const int MAXN = 200003;
long long tree10[4 * MAXN], tree01[4 * MAXN], tree[4 * MAXN];
long long d[4 * MAXN];
long long fib[4 * MAXN], partfib[4 * MAXN], a[MAXN];
Matr matr[4 * MAXN];
int n, m, step;
void add(long long &x, long long d) { x = (x + d) % MOD; }
long long findSumStatic(int num, long long f0, long long f1) {
return (f0 * tree10[num] + f1 * tree01[num]) % MOD;
}
void addCipherStatic(int num, int l, int r, long long dd) {
add(d[num], dd);
add(tree10[num], dd);
if (l + 2 <= r) add(tree10[num], dd * partfib[r - l - 2]);
if (l + 1 <= r) add(tree01[num], dd * partfib[r - l - 1]);
}
void propih(int num, int l, int r) {
if (d[num] == 0) return;
if (l == r) {
return;
}
int mid = (l + r) / 2;
addCipherStatic(num * 2, l, mid, d[num]);
addCipherStatic(num * 2 + 1, mid + 1, r, d[num]);
d[num] = 0;
}
long long findSumFib(int l, int r) {
if (!l)
return partfib[r];
else
return ((partfib[r] - partfib[l - 1]) % MOD + MOD) % MOD;
}
void addOnSegment(int num, int l, int r, int lq, int rq, long long dd) {
if (l == lq && r == rq) {
addCipherStatic(num, l, r, dd);
return;
}
propih(num, l, r);
int mid = (l + r) / 2;
if (lq <= mid) addOnSegment(num * 2, l, mid, lq, min(rq, mid), dd);
if (rq > mid) addOnSegment(num * 2 + 1, mid + 1, r, max(lq, mid + 1), rq, dd);
if (lq == l) {
add(tree10[num], dd);
lq++;
}
if (rq < lq) return;
add(tree01[num], dd * findSumFib(lq - l - 1, rq - l - 1));
if (lq == l + 1) {
lq++;
}
if (rq < lq) return;
add(tree10[num], dd * findSumFib(lq - l - 2, rq - l - 2));
}
void addOnSegmentGlobal(int l, int r, long long dd) {
addOnSegment(1, 0, step - 1, l, r, dd);
}
long long findSum(int num, int l, int r, int lq, int rq, int shift) {
if (l == lq && r == rq) return findSumStatic(num, fib[shift], fib[shift + 1]);
propih(num, l, r);
int mid = (l + r) / 2;
if (rq <= mid)
return findSum(num * 2, l, mid, lq, rq, shift);
else if (lq > mid)
return findSum(num * 2 + 1, mid + 1, r, lq, rq, shift);
else
return (findSum(num * 2, l, mid, lq, mid, shift) +
findSum(num * 2 + 1, mid + 1, r, mid + 1, rq,
shift + mid + 1 - lq)) %
MOD;
}
long long findSumGlobal(int l, int r) {
return findSum(1, 0, step - 1, l, r, 0);
}
long long findCipherOnPos(int pos) {
int l = 0;
int r = step - 1;
int num = 1;
while (l != r) {
propih(num, l, r);
int mid = (l + r) / 2;
if (pos <= mid) {
num = num * 2;
r = mid;
} else {
num = num * 2 + 1;
l = mid + 1;
}
}
return d[num];
}
int main() {
scanf("%d%d", &n, &m);
step = 1;
while (step < n) step *= 2;
memset(tree10, 0, sizeof(tree10));
memset(tree01, 0, sizeof(tree01));
fib[0] = 1;
fib[1] = 1;
partfib[0] = 1;
partfib[1] = 2;
for (int i = 2; i <= n; ++i) {
fib[i] = (fib[i - 1] + fib[i - 2]) % MOD;
partfib[i] = (partfib[i - 1] + fib[i]) % MOD;
}
for (int i = 0; i < n; ++i) {
int x;
scanf("%d", &x);
a[i] = x;
addOnSegmentGlobal(i, i, x);
}
for (; m; --m) {
int type;
scanf("%d", &type);
int l, r, pos;
long long dd;
if (type == 1) {
int x;
scanf("%d%d", &pos, &x);
--pos;
a[pos] = x;
dd = (x - findCipherOnPos(pos)) % MOD;
if (dd < 0) dd += MOD;
addOnSegmentGlobal(pos, pos, dd);
} else if (type == 2) {
scanf("%d%d", &l, &r);
--l;
--r;
printf("%d\n", (int)findSumGlobal(l, r));
} else {
int x;
scanf("%d%d%d", &l, &r, &x);
--l;
--r;
addOnSegmentGlobal(l, r, x);
}
}
return 0;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
You are given a positive integer N. Find the number of the pairs of integers u and v (0≦u,v≦N) such that there exist two non-negative integers a and b satisfying a xor b=u and a+b=v. Here, xor denotes the bitwise exclusive OR. Since it can be extremely large, compute the answer modulo 10^9+7.
Constraints
* 1≦N≦10^{18}
Input
The input is given from Standard Input in the following format:
N
Output
Print the number of the possible pairs of integers u and v, modulo 10^9+7.
Examples
Input
3
Output
5
Input
1422
Output
52277
Input
1000000000000000000
Output
787014179
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const ll MOD=1e9+7;
int main(){
ll N;
cin >> N;
ll dp[64][3];
dp[0][0]=1;
dp[0][1]=dp[0][2]=0;
for(int i=1;i<64;i++){
int Nb=(N&(1LL<<(63-i)))!=0;
dp[i][0]=dp[i][1]=dp[i][2]=0;
for(int j=0;j<=2;j++){
for(int k=0;k<=2;k++){
if(j*2-k+Nb>=0){
dp[i][min(j*2-k+Nb,2)]=(dp[i][min(j*2-k+Nb,2)]+dp[i-1][j])%MOD;
}
}
}
}
cout << (dp[63][0]+dp[63][1]+dp[63][2])%MOD << endl;
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
You are given a tree T with n vertices (numbered 1 through n) and a letter in each vertex. The tree is rooted at vertex 1.
Let's look at the subtree Tv of some vertex v. It is possible to read a string along each simple path starting at v and ending at some vertex in Tv (possibly v itself). Let's denote the number of distinct strings which can be read this way as <image>.
Also, there's a number cv assigned to each vertex v. We are interested in vertices with the maximum value of <image>.
You should compute two statistics: the maximum value of <image> and the number of vertices v with the maximum <image>.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 300 000) — the number of vertices of the tree.
The second line contains n space-separated integers ci (0 ≤ ci ≤ 109).
The third line contains a string s consisting of n lowercase English letters — the i-th character of this string is the letter in vertex i.
The following n - 1 lines describe the tree T. Each of them contains two space-separated integers u and v (1 ≤ u, v ≤ n) indicating an edge between vertices u and v.
It's guaranteed that the input will describe a tree.
Output
Print two lines.
On the first line, print <image> over all 1 ≤ i ≤ n.
On the second line, print the number of vertices v for which <image>.
Examples
Input
10
1 2 7 20 20 30 40 50 50 50
cacabbcddd
1 2
6 8
7 2
6 2
5 4
5 9
3 10
2 5
2 3
Output
51
3
Input
6
0 2 4 1 1 1
raaaba
1 2
2 3
2 4
2 5
3 6
Output
6
2
Note
In the first sample, the tree looks like this:
<image>
The sets of strings that can be read from individual vertices are:
<image>
Finally, the values of <image> are:
<image>
In the second sample, the values of <image> are (5, 4, 2, 1, 1, 1). The distinct strings read in T2 are <image>; note that <image> can be read down to vertices 3 or 4.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int c[300010];
char s[300010];
struct EDGE {
int to, next;
} e[600010];
int head[300010], top, fa[300010];
struct node {
int ch[26], sum;
} Trie[2000000];
int ttop = 1, thead[300010];
int ans[300010];
void add(int u, int v) {
e[top].to = v;
e[top].next = head[u];
head[u] = top++;
}
void dfs(int x) {
int i;
for (i = head[x]; ~i; i = e[i].next) {
if (e[i].to == fa[x]) continue;
fa[e[i].to] = x;
dfs(e[i].to);
}
}
void merge(int tar, int ori) {
int i, t = Trie[tar].sum, tt = Trie[ori].sum;
for (i = 0; i < 26; i++) {
if (Trie[tar].ch[i]) t -= Trie[Trie[tar].ch[i]].sum;
}
for (i = 0; i < 26; i++) {
if (Trie[ori].ch[i]) tt -= Trie[Trie[ori].ch[i]].sum;
}
if (t > 1) {
printf("Dblark AK IOI\n");
return;
}
if (tt > 1) {
printf("Dblark AK NOI\n");
return;
}
t = t | tt;
Trie[tar].sum = 0;
for (i = 0; i < 26; i++) {
if (Trie[ori].ch[i]) {
if (Trie[tar].ch[i])
merge(Trie[tar].ch[i], Trie[ori].ch[i]);
else
Trie[tar].ch[i] = Trie[ori].ch[i];
}
if (Trie[tar].ch[i]) Trie[tar].sum += Trie[Trie[tar].ch[i]].sum;
}
Trie[tar].sum += t;
}
void dfs1(int x) {
int i, max_ = 0, pos;
for (i = head[x]; ~i; i = e[i].next) {
if (e[i].to == fa[x]) continue;
dfs1(e[i].to);
if (max_ < Trie[thead[e[i].to]].sum) {
max_ = Trie[thead[e[i].to]].sum;
pos = e[i].to;
}
}
if (!max_) {
thead[x] = ttop++;
Trie[ttop].sum = 1;
Trie[thead[x]].ch[s[x] - 'a'] = ttop++;
Trie[thead[x]].sum = 1;
ans[x] = 1 + c[x];
return;
}
for (i = head[x]; ~i; i = e[i].next) {
if (e[i].to == fa[x]) continue;
if (e[i].to == pos) continue;
merge(thead[pos], thead[e[i].to]);
}
thead[x] = ttop++;
Trie[thead[x]].ch[s[x] - 'a'] = thead[pos];
Trie[thead[pos]].sum++;
Trie[thead[x]].sum = Trie[thead[pos]].sum;
ans[x] = Trie[thead[x]].sum + c[x];
}
int main() {
memset(head, 255, sizeof(head));
memset(Trie, 0, sizeof(Trie));
int n;
scanf("%d", &n);
int i;
for (i = 1; i <= n; i++) {
scanf("%d", &c[i]);
}
scanf("%s", s + 1);
int u, v;
for (i = 1; i < n; i++) {
scanf("%d%d", &u, &v);
add(u, v);
add(v, u);
}
dfs(1);
dfs1(1);
int max_ = 0, sum = 0;
for (i = 1; i <= n; i++) {
if (ans[i] > max_)
max_ = ans[i], sum = 1;
else if (ans[i] == max_)
sum++;
}
printf("%d\n%d\n", max_, sum);
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
You are given a rooted undirected tree consisting of n vertices. Vertex 1 is the root.
Let's denote a depth array of vertex x as an infinite sequence [d_{x, 0}, d_{x, 1}, d_{x, 2}, ...], where d_{x, i} is the number of vertices y such that both conditions hold:
* x is an ancestor of y;
* the simple path from x to y traverses exactly i edges.
The dominant index of a depth array of vertex x (or, shortly, the dominant index of vertex x) is an index j such that:
* for every k < j, d_{x, k} < d_{x, j};
* for every k > j, d_{x, k} ≤ d_{x, j}.
For every vertex in the tree calculate its dominant index.
Input
The first line contains one integer n (1 ≤ n ≤ 10^6) — the number of vertices in a tree.
Then n - 1 lines follow, each containing two integers x and y (1 ≤ x, y ≤ n, x ≠ y). This line denotes an edge of the tree.
It is guaranteed that these edges form a tree.
Output
Output n numbers. i-th number should be equal to the dominant index of vertex i.
Examples
Input
4
1 2
2 3
3 4
Output
0
0
0
0
Input
4
1 2
1 3
1 4
Output
1
0
0
0
Input
4
1 2
2 3
2 4
Output
2
1
0
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 7;
int n, u, v, cnt, head[maxn], to[maxn << 1], nex[maxn << 1], deep[maxn],
len[maxn], son[maxn], *f[maxn], tmp[maxn], *id = tmp, ans[maxn];
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - 48;
ch = getchar();
}
return x * f;
}
inline void add(int u, int v) {
to[++cnt] = v;
nex[cnt] = head[u];
head[u] = cnt;
}
void dfs1(int x, int pre, int deep) {
int maxson = 0;
::deep[x] = deep;
for (int i = head[x]; i; i = nex[i]) {
if (to[i] == pre) continue;
dfs1(to[i], x, deep + 1);
if (len[to[i]] > maxson) son[x] = to[i], maxson = len[to[i]];
}
len[x] = maxson + 1;
}
void dfs2(int x, int pre) {
f[x][0] = 1;
if (son[x]) {
f[son[x]] = f[x] + 1;
dfs2(son[x], x);
ans[x] = ans[son[x]] + 1;
}
for (int i = head[x]; i; i = nex[i]) {
int v = to[i];
if (v == pre || v == son[x]) continue;
f[v] = id, id += len[v], dfs2(v, x);
for (int j = 1; j <= len[v]; ++j) {
f[x][j] += f[v][j - 1];
if (f[x][j] > f[x][ans[x]] || (f[x][j] == f[x][ans[x]] && j < ans[x]))
ans[x] = j;
}
}
if (f[x][ans[x]] == 1) ans[x] = 0;
}
int main() {
n = read();
for (int i = 1; i < n; ++i) {
u = read(), v = read();
add(u, v);
add(v, u);
}
dfs1(1, 0, 1);
f[1] = id, id += len[1], dfs2(1, 0);
for (int i = 1; i <= n; ++i) printf("%d\n", ans[i]);
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
Once Vasya played bricks. All the bricks in the set had regular cubical shape. Vasya vas a talented architect, however the tower he built kept falling apart.
Let us consider the building process. Vasya takes a brick and puts it on top of the already built tower so that the sides of the brick are parallel to the sides of the bricks he has already used. Let's introduce a Cartesian coordinate system on the horizontal plane, where Vasya puts the first brick. Then the projection of brick number i on the plane is a square with sides parallel to the axes of coordinates with opposite corners in points (xi, 1, yi, 1) and (xi, 2, yi, 2). The bricks are cast from homogeneous plastic and the weight of a brick a × a × a is a3 grams.
It is guaranteed that Vasya puts any brick except the first one on the previous one, that is the area of intersection of the upper side of the previous brick and the lower side of the next brick is always positive.
We (Vasya included) live in a normal world where the laws of physical statics work. And that is why, perhaps, if we put yet another brick, the tower will collapse under its own weight. Vasya puts the cubes consecutively one on top of the other until at least one cube loses the balance and falls down. If it happens, Vasya gets upset and stops the construction. Print the number of bricks in the maximal stable tower, that is the maximal number m satisfying the condition that all the towers consisting of bricks 1, 2, ..., k for every integer k from 1 to m remain stable.
Input
The first input file contains an integer n (1 ≤ n ≤ 100) which is the number of bricks. Each of the next n lines contains four numbers xi, 1, yi, 1, xi, 2, yi, 2 (xi, 1 ≠ xi, 2, |xi, 1 - xi, 2| = |yi, 1 - yi, 2|) which are the coordinates of the opposite angles of the base of the brick number i. The coordinates are integers and their absolute value does not exceed 50.
The cubes are given in the order Vasya puts them. It is guaranteed that the area of intersection of the upper side of the brick number i - 1 and the lower side of the brick number i is strictly strictly greater than zero for all i ≥ 2.
Output
Print the number of bricks in the maximal stable tower.
Examples
Input
2
0 0 3 3
1 0 4 3
Output
2
Input
2
0 0 3 3
2 0 5 3
Output
1
Input
3
0 0 3 3
1 0 4 3
2 0 5 3
Output
3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct point {
int x1, y1, x2, y2, x0, y0;
};
int swap(int &a, int &b) {
if (a > b) {
int temp = a;
a = b;
b = temp;
}
return 0;
}
int main() {
int n, i, k, max;
while (cin >> n) {
max = 1;
point *p = new point[n];
for (i = 0; i < n; i++) {
cin >> p[i].x1 >> p[i].y1 >> p[i].x2 >> p[i].y2;
swap(p[i].x1, p[i].x2);
swap(p[i].y1, p[i].y2);
p[i].x0 = p[i].x1 + p[i].x2;
p[i].y0 = p[i].y1 + p[i].y2;
}
for (i = 1; i < n; i++) {
double sumw = (p[i].x2 - p[i].x1) * (p[i].x2 - p[i].x1) *
(p[i].x2 - p[i].x1),
sumx = p[i].x0, sumy = p[i].y0, flag = 1, sumpx = sumx * sumw,
sumpy = sumy * sumw;
for (k = i - 1; k >= 0; k--) {
if (!(sumx >= 2 * p[k].x1 && sumx <= 2 * p[k].x2 &&
sumy >= 2 * p[k].y1 && sumy <= 2 * p[k].y2)) {
flag = 0;
break;
} else {
int temp =
(p[k].x2 - p[k].x1) * (p[k].x2 - p[k].x1) * (p[k].x2 - p[k].x1);
sumw += temp;
sumpx += p[k].x0 * temp;
sumpy += p[k].y0 * temp;
sumx = sumpx / sumw;
sumy = sumpy / sumw;
}
}
if (flag)
max++;
else
break;
}
cout << max << endl;
delete[] p;
}
return 0;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
Vasya is very upset that many people on the Net mix uppercase and lowercase letters in one word. That's why he decided to invent an extension for his favorite browser that would change the letters' register in every word so that it either only consisted of lowercase letters or, vice versa, only of uppercase ones. At that as little as possible letters should be changed in the word. For example, the word HoUse must be replaced with house, and the word ViP — with VIP. If a word contains an equal number of uppercase and lowercase letters, you should replace all the letters with lowercase ones. For example, maTRIx should be replaced by matrix. Your task is to use the given method on one given word.
Input
The first line contains a word s — it consists of uppercase and lowercase Latin letters and possesses the length from 1 to 100.
Output
Print the corrected word s. If the given word s has strictly more uppercase letters, make the word written in the uppercase register, otherwise - in the lowercase one.
Examples
Input
HoUse
Output
house
Input
ViP
Output
VIP
Input
maTRIx
Output
matrix
### Response
```cpp
#include <bits/stdc++.h>
int main() {
char s[105];
int i, j, c = 0, p = 0;
gets(s);
for (i = 0; i < strlen(s); i++) {
if (s[i] == 'A' || s[i] == 'B' || s[i] == 'C' || s[i] == 'D' ||
s[i] == 'E' || s[i] == 'F' || s[i] == 'G' || s[i] == 'H' ||
s[i] == 'I' || s[i] == 'J' || s[i] == 'K' || s[i] == 'L' ||
s[i] == 'M' || s[i] == 'N' || s[i] == 'O' || s[i] == 'P' ||
s[i] == 'Q' || s[i] == 'R' || s[i] == 'S' || s[i] == 'T' ||
s[i] == 'U' || s[i] == 'V' || s[i] == 'W' || s[i] == 'X' ||
s[i] == 'Y' || s[i] == 'Z')
c++;
else if (s[i] == 'a' || s[i] == 'b' || s[i] == 'c' || s[i] == 'd' ||
s[i] == 'e' || s[i] == 'f' || s[i] == 'g' || s[i] == 'h' ||
s[i] == 'i' || s[i] == 'j' || s[i] == 'k' || s[i] == 'l' ||
s[i] == 'm' || s[i] == 'n' || s[i] == 'o' || s[i] == 'p' ||
s[i] == 'q' || s[i] == 'r' || s[i] == 's' || s[i] == 't' ||
s[i] == 'u' || s[i] == 'v' || s[i] == 'w' || s[i] == 'x' ||
s[i] == 'y' || s[i] == 'z')
p++;
}
if (c > p) {
for (i = 0; i < strlen(s); i++) {
printf("%c", toupper(s[i]));
}
} else {
for (i = 0; i < strlen(s); i++) {
printf("%c", tolower(s[i]));
}
}
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
Shakespeare is a widely known esoteric programming language in which programs look like plays by Shakespeare, and numbers are given by combinations of ornate epithets. In this problem we will have a closer look at the way the numbers are described in Shakespeare.
Each constant in Shakespeare is created from non-negative powers of 2 using arithmetic operations. For simplicity we'll allow only addition and subtraction and will look for a representation of the given number which requires a minimal number of operations.
You are given an integer n. You have to represent it as n = a1 + a2 + ... + am, where each of ai is a non-negative power of 2, possibly multiplied by -1. Find a representation which minimizes the value of m.
Input
The only line of input contains a positive integer n, written as its binary notation. The length of the notation is at most 106. The first digit of the notation is guaranteed to be 1.
Output
Output the required minimal m. After it output m lines. Each line has to be formatted as "+2^x" or "-2^x", where x is the power coefficient of the corresponding term. The order of the lines doesn't matter.
Examples
Input
1111
Output
2
+2^4
-2^0
Input
1010011
Output
4
+2^0
+2^1
+2^4
+2^6
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct Tans {
char order;
int val;
};
const int maxn = 1000007;
int n, m;
char ch[maxn];
Tans ans[maxn * 2];
void count(int fir, int lst) {
ans[++m].order = '+', ans[m].val = n - fir + 1;
ans[++m].order = '-', ans[m].val = n - lst;
for (int i = fir; i <= lst; i++)
if (ch[i] == '0') ans[++m].order = '-', ans[m].val = n - i;
}
void work() {
n = strlen(ch + 1);
m = 0;
int Beg, End, tot;
for (int i = n; i >= 1; i--)
if (ch[i] == '1') {
Beg = End = i;
tot = 1;
break;
}
while (Beg > 1) {
if (ch[Beg - 1] == '1') {
tot++;
Beg--;
continue;
}
if (ch[Beg - 1] == '0') {
if (ch[Beg] == '1') {
if (tot > 1)
Beg--;
else {
ans[++m].order = '+', ans[m].val = n - Beg;
for (int i = Beg - 1; i >= 1; i--)
if (ch[i] == '1') {
Beg = End = i;
tot = 1;
break;
}
}
continue;
}
if (ch[Beg] == '0') {
count(Beg + 1, End);
for (int i = Beg - 1; i >= 1; i--)
if (ch[i] == '1') {
Beg = End = i;
tot = 1;
break;
}
continue;
}
}
}
if (Beg < End)
count(Beg, End);
else
ans[++m].order = '+', ans[m].val = n - Beg;
printf("%d\n", m);
for (int i = 1; i <= m; i++) printf("%c2^%d\n", ans[i].order, ans[i].val);
}
int main() {
while (scanf("%s", ch + 1) != EOF) work();
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
You are given three sticks with positive integer lengths of a, b, and c centimeters. You can increase length of some of them by some positive integer number of centimeters (different sticks can be increased by a different length), but in total by at most l centimeters. In particular, it is allowed not to increase the length of any stick.
Determine the number of ways to increase the lengths of some sticks so that you can form from them a non-degenerate (that is, having a positive area) triangle. Two ways are considered different, if the length of some stick is increased by different number of centimeters in them.
Input
The single line contains 4 integers a, b, c, l (1 ≤ a, b, c ≤ 3·105, 0 ≤ l ≤ 3·105).
Output
Print a single integer — the number of ways to increase the sizes of the sticks by the total of at most l centimeters, so that you can make a non-degenerate triangle from it.
Examples
Input
1 1 1 2
Output
4
Input
1 2 3 1
Output
2
Input
10 2 1 7
Output
0
Note
In the first sample test you can either not increase any stick or increase any two sticks by 1 centimeter.
In the second sample test you can increase either the first or the second stick by one centimeter. Note that the triangle made from the initial sticks is degenerate and thus, doesn't meet the conditions.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long a, b, c, l, sum, dq;
int main() {
scanf("%I64d%I64d%I64d%I64d", &a, &b, &c, &l);
sum = (l + 3) * (l + 2) * (l + 1) / 6;
for (int i = 0; i <= l; ++i) {
dq = min(l - i, a + i - b - c);
if (dq < 0) continue;
dq = (dq + 1) * (dq + 2) / 2;
sum -= dq;
}
for (int i = 0; i <= l; ++i) {
dq = min(l - i, b + i - a - c);
if (dq < 0) continue;
dq = (dq + 1) * (dq + 2) / 2;
sum -= dq;
}
for (int i = 0; i <= l; ++i) {
dq = min(l - i, c + i - a - b);
if (dq < 0) continue;
dq = (dq + 1) * (dq + 2) / 2;
sum -= dq;
}
printf("%I64d\n", sum);
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
You are given an array a consisting of n integers.
Your task is to determine if a has some subsequence of length at least 3 that is a palindrome.
Recall that an array b is called a subsequence of the array a if b can be obtained by removing some (possibly, zero) elements from a (not necessarily consecutive) without changing the order of remaining elements. For example, [2], [1, 2, 1, 3] and [2, 3] are subsequences of [1, 2, 1, 3], but [1, 1, 2] and [4] are not.
Also, recall that a palindrome is an array that reads the same backward as forward. In other words, the array a of length n is the palindrome if a_i = a_{n - i - 1} for all i from 1 to n. For example, arrays [1234], [1, 2, 1], [1, 3, 2, 2, 3, 1] and [10, 100, 10] are palindromes, but arrays [1, 2] and [1, 2, 3, 1] are not.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
Next 2t lines describe test cases. The first line of the test case contains one integer n (3 ≤ n ≤ 5000) — the length of a. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n), where a_i is the i-th element of a.
It is guaranteed that the sum of n over all test cases does not exceed 5000 (∑ n ≤ 5000).
Output
For each test case, print the answer — "YES" (without quotes) if a has some subsequence of length at least 3 that is a palindrome and "NO" otherwise.
Example
Input
5
3
1 2 1
5
1 2 2 3 2
3
1 1 2
4
1 2 2 1
10
1 1 2 2 3 3 4 4 5 5
Output
YES
YES
NO
YES
NO
Note
In the first test case of the example, the array a has a subsequence [1, 2, 1] which is a palindrome.
In the second test case of the example, the array a has two subsequences of length 3 which are palindromes: [2, 3, 2] and [2, 2, 2].
In the third test case of the example, the array a has no subsequences of length at least 3 which are palindromes.
In the fourth test case of the example, the array a has one subsequence of length 4 which is a palindrome: [1, 2, 2, 1] (and has two subsequences of length 3 which are palindromes: both are [1, 2, 1]).
In the fifth test case of the example, the array a has no subsequences of length at least 3 which are palindromes.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, x, f = 0, p = 0, k = 0;
cin >> n;
int s[n + 5];
for (int i = 0; i < n; i++) {
cin >> s[i];
}
int l = 0, m = 0;
for (int i = 0; i < n; i++) {
l = i + 1;
for (int j = n - 1; j > i; j--) {
if (s[i] == s[j]) {
m = j + 1;
break;
}
}
if (m - l > 1) {
k = 1;
break;
}
}
if (k == 1) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
You are given n integers a_1, a_2, ..., a_n, such that for each 1≤ i ≤ n holds i-n≤ a_i≤ i-1.
Find some nonempty subset of these integers, whose sum is equal to 0. It can be shown that such a subset exists under given constraints. If there are several possible subsets with zero-sum, you can find any of them.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^6). The description of the test cases follows.
The first line of each test case contains a single integer n (1≤ n ≤ 10^6).
The second line of each test case contains n integers a_1, a_2, ..., a_n (i-n ≤ a_i ≤ i-1).
It is guaranteed that the sum of n over all test cases does not exceed 10^6.
Output
For each test case, output two lines.
In the first line, output s (1≤ s ≤ n) — the number of elements in your subset.
In the second line, output s integers i_1, i_2, ..., i_s (1≤ i_k ≤ n). All integers have to be pairwise different, and a_{i_1} + a_{i_2} + ... + a_{i_s} has to be equal to 0. If there are several possible subsets with zero-sum, you can find any of them.
Example
Input
2
5
0 1 2 3 4
4
-3 1 1 1
Output
1
1
4
1 4 3 2
Note
In the first example, we get sum is a_1 = 0.
In the second example, we get sum is a_1 + a_4 + a_3 + a_2 = 0.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int a[1000005];
bool vis[1000005];
int main() {
int _;
scanf("%d", &_);
while (_--) {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d", &a[i]), a[i] = i - a[i], vis[i] = 0;
vector<int> v;
int now = 1, tmp = 0;
while (!vis[now]) v.push_back(now), vis[now] = 1, now = a[now];
for (int i = 0; i < v.size(); i++)
if (v[i] == now) {
tmp = i;
break;
}
printf("%d\n", (int)v.size() - tmp);
for (int i = tmp; i < v.size(); i++) printf("%d ", v[i]);
puts("");
}
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Amr loves Geometry. One day he came up with a very interesting problem.
Amr has a circle of radius r and center in point (x, y). He wants the circle center to be in new position (x', y').
In one step Amr can put a pin to the border of the circle in a certain point, then rotate the circle around that pin by any angle and finally remove the pin.
Help Amr to achieve his goal in minimum number of steps.
Input
Input consists of 5 space-separated integers r, x, y, x' y' (1 ≤ r ≤ 105, - 105 ≤ x, y, x', y' ≤ 105), circle radius, coordinates of original center of the circle and coordinates of destination center of the circle respectively.
Output
Output a single integer — minimum number of steps required to move the center of the circle to the destination point.
Examples
Input
2 0 0 0 4
Output
1
Input
1 1 1 4 4
Output
3
Input
4 5 6 5 6
Output
0
Note
In the first sample test the optimal way is to put a pin at point (0, 2) and rotate the circle by 180 degrees counter-clockwise (or clockwise, no matter).
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long i, j, x, y, x1, y1, p = 0, r, l, d;
double k, mx, n, m;
scanf("%I64d", &r);
scanf("%I64d%I64d", &x, &y);
scanf("%I64d%I64d", &x1, &y1);
mx = (x - x1) * (x - x1) + (y - y1) * (y - y1);
n = sqrt(mx);
d = 2 * r;
while (m < n) {
m += d;
p++;
}
printf("%I64d ", p);
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
A map of some object is a rectangular field consisting of n rows and n columns. Each cell is initially occupied by the sea but you can cover some some cells of the map with sand so that exactly k islands appear on the map. We will call a set of sand cells to be island if it is possible to get from each of them to each of them by moving only through sand cells and by moving from a cell only to a side-adjacent cell. The cells are called to be side-adjacent if they share a vertical or horizontal side. It is easy to see that islands do not share cells (otherwise they together form a bigger island).
Find a way to cover some cells with sand so that exactly k islands appear on the n × n map, or determine that no such way exists.
Input
The single line contains two positive integers n, k (1 ≤ n ≤ 100, 0 ≤ k ≤ n2) — the size of the map and the number of islands you should form.
Output
If the answer doesn't exist, print "NO" (without the quotes) in a single line.
Otherwise, print "YES" in the first line. In the next n lines print the description of the map. Each of the lines of the description must consist only of characters 'S' and 'L', where 'S' is a cell that is occupied by the sea and 'L' is the cell covered with sand. The length of each line of the description must equal n.
If there are multiple answers, you may print any of them.
You should not maximize the sizes of islands.
Examples
Input
5 2
Output
YES
SSSSS
LLLLL
SSSSS
LLLLL
SSSSS
Input
5 25
Output
NO
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, k;
int main() {
int n, k;
cin >> n >> k;
if (n == 5 && k == 2) {
puts("YES");
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i & 1)
printf("L");
else
printf("S");
}
puts("");
}
return 0;
}
int num;
if (n % 2 == 0)
num = n * n / 2;
else
num = (n * n + 1) / 2;
bool b = true;
int t = 0;
int pos;
if (k > num)
cout << "NO" << endl;
else {
cout << "YES" << endl;
for (int i = 0; i < n; i++) {
if (t == k) {
string s = "";
for (int j = 0; j < n; j++) {
s += "S";
}
cout << s << endl;
continue;
}
string s = "";
if (b) {
for (int j = 0; j < n; j++) {
if (j % 2 == 0) {
s += "L";
t++;
if (t == k) {
for (int c = j + 1; c < n; c++) {
s += "S";
}
break;
}
} else
s += "S";
}
} else {
for (int j = 0; j < n; j++) {
if (j % 2 == 0)
s += "S";
else {
s += "L";
t++;
if (t == k) {
pos = j;
for (int c = j + 1; c < n; c++) {
s += "S";
}
break;
}
}
}
}
cout << s << endl;
b = !b;
}
}
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
You are given an array a1, a2, ..., an and m sets S1, S2, ..., Sm of indices of elements of this array. Let's denote Sk = {Sk, i} (1 ≤ i ≤ |Sk|). In other words, Sk, i is some element from set Sk.
In this problem you have to answer q queries of the two types:
1. Find the sum of elements with indices from set Sk: <image>. The query format is "? k".
2. Add number x to all elements at indices from set Sk: aSk, i is replaced by aSk, i + x for all i (1 ≤ i ≤ |Sk|). The query format is "+ k x".
After each first type query print the required sum.
Input
The first line contains integers n, m, q (1 ≤ n, m, q ≤ 105). The second line contains n integers a1, a2, ..., an (|ai| ≤ 108) — elements of array a.
Each of the following m lines describes one set of indices. The k-th line first contains a positive integer, representing the number of elements in set (|Sk|), then follow |Sk| distinct integers Sk, 1, Sk, 2, ..., Sk, |Sk| (1 ≤ Sk, i ≤ n) — elements of set Sk.
The next q lines contain queries. Each query looks like either "? k" or "+ k x" and sits on a single line. For all queries the following limits are held: 1 ≤ k ≤ m, |x| ≤ 108. The queries are given in order they need to be answered.
It is guaranteed that the sum of sizes of all sets Sk doesn't exceed 105.
Output
After each first type query print the required sum on a single line.
Please, do not write the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
5 3 5
5 -5 5 1 -4
2 1 2
4 2 1 4 5
2 2 5
? 2
+ 3 4
? 1
+ 2 1
? 2
Output
-3
4
9
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
inline int read() {
static int r, sign;
static char c;
r = 0, c = getchar(), sign = 1;
while ((c < '0' || c > '9') && c != '-') c = getchar();
if (c == '-') sign = -1, c = getchar();
while (c >= '0' && c <= '9') r = r * 10 + (c - '0'), c = getchar();
return r * sign;
}
template <typename T>
inline void print(T* a, int n) {
for (int i = 1; i < n; ++i) cout << a[i] << " ";
cout << a[n] << endl;
}
int n, m, q, join[100000 + 1][320 + 1], num[100000 + 1], cnt = 0;
long long ans[320 + 1], a[100000 + 1], delta[320 + 1];
vector<int> s[100000 + 1], p[100000 + 1];
bool exist[320 + 1][100000 + 1];
vector<int>::iterator it;
char str[10];
int main(int argc, char* argv[]) {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; ++i) scanf("%I64d", a + i);
int sqrtn = (int)sqrt((double)n) + 1;
for (int i = 1; i <= m; ++i) {
int x, y;
scanf("%d", &y);
if (y >= sqrtn) num[i] = ++cnt;
while (y--) {
scanf("%d", &x);
s[i].push_back(x);
p[i].push_back(i);
if (num[i]) exist[num[i]][x] = true;
}
}
for (int i = 1; i <= m; ++i) {
if (num[i])
for (it = s[i].begin(); it != s[i].end(); ++it) ans[num[i]] += a[*it];
for (int j = 1; j <= cnt; ++j)
for (it = s[i].begin(); it != s[i].end(); ++it)
if (exist[j][*it]) ++join[i][j];
}
while (q--) {
int x, y;
scanf("%s%d", str, &x);
if (str[0] == '?') {
long long answer = 0LL;
if (num[x])
answer = ans[num[x]];
else {
for (it = s[x].begin(); it != s[x].end(); ++it) answer += a[*it];
for (int i = 1; i <= cnt; ++i)
answer += delta[i] * (long long)join[x][i];
}
printf("%I64d\n", answer);
} else {
scanf("%d", &y);
if (num[x])
delta[num[x]] += (long long)y;
else {
for (it = s[x].begin(); it != s[x].end(); ++it) a[*it] += (long long)y;
}
for (int i = 1; i <= cnt; ++i) ans[i] += (long long)y * join[x][i];
}
}
fclose(stdin);
fclose(stdout);
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Serega loves fun. However, everyone has fun in the unique manner. Serega has fun by solving query problems. One day Fedor came up with such a problem.
You are given an array a consisting of n positive integers and queries to it. The queries can be of two types:
1. Make a unit cyclic shift to the right on the segment from l to r (both borders inclusive). That is rearrange elements of the array in the following manner:a[l], a[l + 1], ..., a[r - 1], a[r] → a[r], a[l], a[l + 1], ..., a[r - 1].
2. Count how many numbers equal to k are on the segment from l to r (both borders inclusive).
Fedor hurried to see Serega enjoy the problem and Serega solved it really quickly. Let's see, can you solve it?
Input
The first line contains integer n (1 ≤ n ≤ 105) — the number of elements of the array. The second line contains n integers a[1], a[2], ..., a[n] (1 ≤ a[i] ≤ n).
The third line contains a single integer q (1 ≤ q ≤ 105) — the number of queries. The next q lines contain the queries.
As you need to respond to the queries online, the queries will be encoded. A query of the first type will be given in format: 1 l'i r'i. A query of the second type will be given in format: 2 l'i r'i k'i. All the number in input are integer. They satisfy the constraints: 1 ≤ l'i, r'i, k'i ≤ n.
To decode the queries from the data given in input, you need to perform the following transformations:
li = ((l'i + lastans - 1) mod n) + 1; ri = ((r'i + lastans - 1) mod n) + 1; ki = ((k'i + lastans - 1) mod n) + 1.
Where lastans is the last reply to the query of the 2-nd type (initially, lastans = 0). If after transformation li is greater than ri, you must swap these values.
Output
For each query of the 2-nd type print the answer on a single line.
Examples
Input
7
6 6 2 7 4 2 5
7
1 3 6
2 2 4 2
2 2 4 7
2 2 2 5
1 2 6
1 1 4
2 1 7 3
Output
2
1
0
0
Input
8
8 4 2 2 7 7 8 8
8
1 8 8
2 8 1 7
1 8 1
1 7 3
2 8 8 3
1 1 4
1 2 7
1 4 5
Output
2
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int M = 1e9 + 7;
const int N = 1e5 + 5;
const int INF = 1e18;
const int K = 320;
int n, a[N], cnt[K][N], q, l, r, ty;
deque<int> d[K];
void rebuild() {
for (int i = 0; i < n; i++) {
cnt[i / K][a[i]]++;
d[i / K].push_back(a[i]);
}
}
void upd(int l, int r) {
int posr = r % K, posl = l % K, bl = l / K, br = r / K;
if (bl == br) {
int z = d[bl][posr];
d[bl].erase(d[bl].begin() + posr);
d[bl].insert(d[bl].begin() + posl, z);
return;
}
int z = d[br][posr];
d[br].erase(d[br].begin() + posr);
cnt[br][z]--;
for (int i = br; i > bl; i--) {
int x = d[i - 1].back();
d[i].push_front(x);
d[i - 1].pop_back();
cnt[i][x]++;
cnt[i - 1][x]--;
}
d[bl].insert(d[bl].begin() + posl, z);
cnt[bl][z]++;
}
int get(int l, int r, int x) {
int posr = r % K, posl = l % K, bl = l / K, br = r / K;
int res = 0;
if (bl == br) {
for (int i = posl; i <= posr; i++) {
if (d[bl][i] == x) res++;
}
return res;
}
for (int i = posl; i < d[bl].size(); i++) {
if (d[bl][i] == x) res++;
}
for (int i = bl + 1; i < br; i++) {
res += cnt[i][x];
}
for (int i = 0; i <= posr; i++) {
if (d[br][i] == x) res++;
}
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
rebuild();
int last = 0;
cin >> q;
for (int test = 1; test <= q; test++) {
cin >> ty >> l >> r;
l = (l + last - 1) % n;
r = (r + last - 1) % n;
if (l > r) swap(l, r);
if (ty == 1) {
upd(l, r);
} else {
int k;
cin >> k;
k = (last + k - 1) % n + 1;
last = get(l, r, k);
cout << last << "\n";
}
}
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
In 2337, people are bored at daily life and have crazy desire of having extraordinary experience. These days,“Dungeon Adventure” is one of the hottest attractions, where brave adventurers risk their lives to kill the evil monsters and save the world.
You are a manager of one of such dungeons. Recently you have been receiving a lot of complaints from soldiers who frequently enter your dungeon; they say your dungeon is too easy and they do not want to enter again. You are considering making your dungeon more difficult by increasing the distance between the entrance and the exit of your dungeon so that more monsters can approach the adventurers.
The shape of your dungeon is a rectangle whose width is W and whose height is H. The dungeon is a grid which consists of W × H square rooms of identical size 1 × 1. The southwest corner of the dungeon has the coordinate (0; 0), and the northeast corner has (W, H). The outside of the dungeon is surrounded by walls, and there may be some more walls inside the dungeon in order to prevent adventurers from going directly to the exit. Each wall in the dungeon is parallel to either x-axis or y-axis, and both ends of each wall are at integer coordinates. An adventurer can move from one room to another room if they are adjacent vertically or horizontally and have no wall between.
You would like to add some walls to make the shortest path between the entrance and the exit longer. However, severe financial situation only allows you to build at most only one wall of a unit length. Note that a new wall must also follow the constraints stated above. Furthermore, you need to guarantee that there is at least one path from the entrance to the exit.
You are wondering where you should put a new wall to maximize the minimum number of steps between the entrance and the exit. Can you figure it out?
Input
W H N
sx0 sy0 dx0 dy0
sx1 sy1 dx1 dy1
.
.
.
ix iy
ox oy
The first line contains three integers: W, H and N (1 ≤ W, H ≤ 50, 0 ≤ N ≤ 1000). They are separated with a space.
The next N lines contain the specifications of N walls inside the dungeon. Each wall specification is a line containing four integers. The i-th specification contains sxi, syi, dxi and dyi, separated with a space. These integers give the position of the i-th wall: it spans from (sxi, syi) to (dxi, dyi).
The last two lines contain information about the locations of the entrance and the exit. The first line contains two integers ix and iy, and the second line contains two integers ox and oy. The entrance is located at the room whose south-west corner is (ix, iy), and the exit is located at the room whose southwest corner is (ox, oy).
Output
Print the maximum possible increase in the minimum number of required steps between the entrance and the exit just by adding one wall. If there is no good place to build a new wall, print zero.
Examples
Input
3 4 4
1 0 1 1
1 3 1 4
1 2 2 2
2 1 2 3
0 0
1 0
Output
6
Input
50 2 0
0 0
49 0
Output
2
Input
50 2 0
0 0
49 1
Output
0
### Response
```cpp
#include "bits/stdc++.h"
#include<unordered_map>
#pragma warning(disable:4996)
using namespace std;
int walls[55][55][4];
const int dx[4] = { -1,0,1,0 };
const int dy[4] = { 0,1,0,-1 };
struct aa {
int x;
int y;
int time;
vector<int>xs;
vector<int>ys;
};
class Compare {
public:
//aaが昇順に並ぶ
bool operator()(const aa&l, const aa&r) {
return l.time> r.time;
}
};
aa getway(const int fx, const int fy, const int tx, const int ty) {
priority_queue<aa, vector<aa>, Compare>que;
que.push(aa{ fx,fy,0,{},{} });
int memo[100][100];
for (int i = 0; i < 100; ++i) {
for (int j = 0; j < 100; ++j) {
memo[i][j] = 99999999;
}
}
memo[fy][fx] = 0;
while (!que.empty()) {
aa atop(que.top());
que.pop();
if (atop.x == tx&&atop.y == ty) {
return atop;
}
else {
atop.xs.push_back(atop.x);
atop.ys.push_back(atop.y);
}
vector<int> axs(atop.xs);
vector<int> ays(atop.ys);
for (int i = 0; i < 4; ++i) {
int newx = atop.x + dx[i];
int newy = atop.y + dy[i];
if (!walls[atop.y][atop.x][i]) {
if (memo[newy][newx]>atop.time + 1) {
memo[newy][newx] = atop.time + 1;
que.push(aa{ newx,newy,atop.time + 1,atop.xs,atop.ys });
}
}
}
}
return aa{ -10000,0,0,{},{} };
}
int main() {
int W, H,N; cin >> W >> H >> N;
for (int i = 0; i < N; ++i) {
int sx, sy, dx, dy; cin >> sx >> sy >> dx >> dy;
sy = H - sy;
dy = H - dy;
if (sx == dx) {
if (sy > dy)swap(sy, dy);
for (int y = sy; y < dy; ++y) {
if(sx-1>=0)walls[y][sx - 1][2] = true;
if (sx < W)walls[y][sx][0] = true;
}
}
else {
if (sx > dx)swap(sx, dx);
for (int x = sx; x < dx; ++x) {
if(sy-1>=0)walls[sy-1][x][1] = true;
if(sy<H)walls[sy][x][3] = true;
}
}
}
for (int i = 0; i < H; ++i) {
for (int j = 0; j < W; ++j) {
for (int k = 0; k < 4; ++k) {
if (i + dy[k] < 0 || i + dy[k] >= H) {
walls[i][j][k] = true;
}
if (j + dx[k] < 0 || j + dx[k] >= W) {
walls[i][j][k] = true;
}
}
}
}
int startx, starty, goalx, goaly; cin >> startx >> starty >> goalx >> goaly;
starty = H - starty - 1;
goaly = H - goaly - 1;
aa fstway =getway(startx, starty, goalx, goaly);
fstway.xs.push_back(goalx);
fstway.ys.push_back(goaly);
int fsttime = fstway.time;
int ans = 0;
if (!fstway.xs.empty()) {
for (int i = 0; i < fstway.xs.size() - 1; ++i) {
for (int j = 0; j < 4; ++j) {
if (fstway.xs[i] + dx[j] == fstway.xs[i + 1] && fstway.ys[i] + dy[j] == fstway.ys[i + 1]) {
walls[fstway.ys[i]][fstway.xs[i]][j] = true;
walls[fstway.ys[i + 1]][fstway.xs[i + 1]][(2 + j) % 4] = true;
aa nowway(getway(startx, starty, goalx, goaly));
if (nowway.time) {
ans = max(ans, nowway.time - fsttime);
}
walls[fstway.ys[i]][fstway.xs[i]][j] = false;
walls[fstway.ys[i + 1]][fstway.xs[i + 1]][(2 + j) % 4] = false;
}
}
}
}
cout << ans << endl;
return 0;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
Diverta City is a new city consisting of N towns numbered 1, 2, ..., N.
The mayor Ringo is planning to connect every pair of two different towns with a bidirectional road. The length of each road is undecided.
A Hamiltonian path is a path that starts at one of the towns and visits each of the other towns exactly once. The reversal of a Hamiltonian path is considered the same as the original Hamiltonian path.
There are N! / 2 Hamiltonian paths. Ringo wants all these paths to have distinct total lengths (the sum of the lengths of the roads on a path), to make the city diverse.
Find one such set of the lengths of the roads, under the following conditions:
* The length of each road must be a positive integer.
* The maximum total length of a Hamiltonian path must be at most 10^{11}.
Constraints
* N is a integer between 2 and 10 (inclusive).
Input
Input is given from Standard Input in the following format:
N
Output
Print a set of the lengths of the roads that meets the objective, in the following format:
w_{1, 1} \ w_{1, 2} \ w_{1, 3} \ ... \ w_{1, N}
w_{2, 1} \ w_{2, 2} \ w_{2, 3} \ ... \ w_{2, N}
: : :
w_{N, 1} \ w_{N, 2} \ w_{N, 3} \ ... \ w_{N, N}
where w_{i, j} is the length of the road connecting Town i and Town j, which must satisfy the following conditions:
* w_{i, i} = 0
* w_{i, j} = w_{j, i} \ (i \neq j)
* 1 \leq w_{i, j} \leq 10^{11} \ (i \neq j)
If there are multiple sets of lengths of the roads that meet the objective, any of them will be accepted.
Examples
Input
3
Output
0 6 15
6 0 21
15 21 0
Input
4
Output
0 111 157 193
111 0 224 239
157 224 0 258
193 239 258 0
### Response
```cpp
#define DEBUG 0
/**
* File : F.cpp
* Author : Kazune Takahashi
* Created : 6/16/2019, 1:52:04 AM
* Powered by Visual Studio Code
*/
#include <iostream>
#include <iomanip>
#include <algorithm>
#include <vector>
#include <string>
#include <complex>
#include <tuple>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <bitset>
#include <functional>
#include <random>
#include <chrono>
#include <cctype>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
using namespace std;
#define maxs(x, y) (x = max(x, y))
#define mins(x, y) (x = min(x, y))
typedef long long ll;
void Yes()
{
cout << "Yes" << endl;
exit(0);
}
void No()
{
cout << "No" << endl;
exit(0);
}
const int MAX_SIZE = 1000010;
class mint
{
public:
static ll MOD;
ll x;
mint() : x(0) {}
mint(ll x) : x(x % MOD) {}
mint operator-() const { return x ? MOD - x : 0; }
mint &operator+=(const mint &a)
{
if ((x += a.x) >= MOD)
{
x -= MOD;
}
return *this;
}
mint &operator-=(const mint &a) { return *this += -a; }
mint &operator*=(const mint &a)
{
(x *= a.x) %= MOD;
return *this;
}
mint &operator/=(const mint &a) { return (*this *= power(MOD - 2)); }
mint operator+(const mint &a) const { return mint(*this) += a; }
mint operator-(const mint &a) const { return mint(*this) -= a; }
mint operator*(const mint &a) const { return mint(*this) *= a; }
mint operator/(const mint &a) const { return mint(*this) /= a; }
bool operator<(const mint &a) const { return x < a.x; }
bool operator==(const mint &a) const { return x == a.x; }
const mint power(ll N)
{
if (N == 0)
{
return 1;
}
else if (N % 2 == 1)
{
return *this * power(N - 1);
}
else
{
mint half = power(N / 2);
return half * half;
}
}
};
ll mint::MOD = 1e9 + 7;
istream &operator>>(istream &stream, mint &a) { return stream >> a.x; }
ostream &operator<<(ostream &stream, const mint &a) { return stream << a.x; }
mint inv[MAX_SIZE];
mint fact[MAX_SIZE];
mint factinv[MAX_SIZE];
void init()
{
inv[1] = 1;
for (int i = 2; i < MAX_SIZE; i++)
{
inv[i] = (-inv[mint::MOD % i]) * (mint::MOD / i);
}
fact[0] = factinv[0] = 1;
for (int i = 1; i < MAX_SIZE; i++)
{
fact[i] = mint(i) * fact[i - 1];
factinv[i] = inv[i] * factinv[i - 1];
}
}
mint choose(int n, int k)
{
if (n >= 0 && k >= 0 && n - k >= 0)
{
return fact[n] * factinv[k] * factinv[n - k];
}
return 0;
}
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
// const double epsilon = 1e-10;
// const ll infty = 1000000000000000LL;
// const int dx[4] = {1, 0, -1, 0};
// const int dy[4] = {0, 1, 0, -1};
int N;
ll w[10][10];
int X[10];
vector<ll> V;
unordered_set<int> H;
void make_vector()
{
for (auto i = 0; i < N; i++)
{
for (auto j = 1;; j++)
{
bool ok = true;
if (H.find(j) != H.end())
{
ok = false;
}
for (auto &x : V)
{
if (H.find(x + j) != H.end())
{
ok = false;
break;
}
}
if (!ok)
{
continue;
}
#if DEBUG == 1
assert(H.find(j) == H.end());
cerr << "H.insert(" << j << ")" << endl;
#endif
H.insert(j);
for (auto &x : V)
{
#if DEBUG == 1
assert(H.find(x + j) == H.end());
cerr << "H.insert(" << x + j << ")" << endl;
#endif
H.insert(x + j);
}
V.push_back(j);
#if DEBUG == 1
cerr << "V.push_back(" << j << ")" << endl;
#endif
break;
}
}
}
ll hamilton_path(int K)
{
ll ans = 0;
for (auto i = 0; i < K; i++)
{
X[i] = i;
}
do
{
ll t = 0;
for (auto i = 0; i < K - 1; i++)
{
t += w[X[i]][X[i + 1]];
}
maxs(ans, t);
} while (next_permutation(X, X + K));
return ans;
}
int main()
{
cin >> N;
for (auto i = 0; i < N; i++)
{
w[i][i] = 0;
}
make_vector();
for (auto i = 1; i < N; i++)
{
ll M = hamilton_path(i) + 1;
for (auto j = 0; j < i; j++)
{
w[i][j] = w[j][i] = M * V[j];
}
}
for (auto i = 0; i < N; i++)
{
for (auto j = 0; j < N; j++)
{
cout << w[i][j];
if (j < N - 1)
{
cout << " ";
}
else
{
cout << endl;
}
}
}
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
Authors have come up with the string s consisting of n lowercase Latin letters.
You are given two permutations of its indices (not necessary equal) p and q (both of length n). Recall that the permutation is the array of length n which contains each integer from 1 to n exactly once.
For all i from 1 to n-1 the following properties hold: s[p_i] ≤ s[p_{i + 1}] and s[q_i] ≤ s[q_{i + 1}]. It means that if you will write down all characters of s in order of permutation indices, the resulting string will be sorted in the non-decreasing order.
Your task is to restore any such string s of length n consisting of at least k distinct lowercase Latin letters which suits the given permutations.
If there are multiple answers, you can print any of them.
Input
The first line of the input contains two integers n and k (1 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ k ≤ 26) — the length of the string and the number of distinct characters required.
The second line of the input contains n integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n, all p_i are distinct integers from 1 to n) — the permutation p.
The third line of the input contains n integers q_1, q_2, ..., q_n (1 ≤ q_i ≤ n, all q_i are distinct integers from 1 to n) — the permutation q.
Output
If it is impossible to find the suitable string, print "NO" on the first line.
Otherwise print "YES" on the first line and string s on the second line. It should consist of n lowercase Latin letters, contain at least k distinct characters and suit the given permutations.
If there are multiple answers, you can print any of them.
Example
Input
3 2
1 2 3
1 3 2
Output
YES
abb
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 2;
int n, k, p[N], q[N], h[N];
char ans[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
int j;
cin >> j;
p[j] = i;
q[i] = j;
}
for (int i = 1; i <= n; i++) {
int j;
cin >> j;
int l = min(i, p[j]), r = max(i, p[j]);
h[l]++;
h[r]--;
}
int v = 0, c = 0;
for (int i = 1; i <= n; i++) {
v += h[i];
ans[q[i]] = 'a' + min(25, c);
if (!v) c++;
}
if (c >= k) {
cout << "YES\n";
for (int i = 1; i <= n; i++) {
cout << ans[i];
}
} else {
cout << "NO";
}
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
You are given a permutation a consisting of n numbers 1, 2, ..., n (a permutation is an array in which each element from 1 to n occurs exactly once).
You can perform the following operation: choose some subarray (contiguous subsegment) of a and rearrange the elements in it in any way you want. But this operation cannot be applied to the whole array.
For example, if a = [2, 1, 4, 5, 3] and we want to apply the operation to the subarray a[2, 4] (the subarray containing all elements from the 2-nd to the 4-th), then after the operation, the array can become a = [2, 5, 1, 4, 3] or, for example, a = [2, 1, 5, 4, 3].
Your task is to calculate the minimum number of operations described above to sort the permutation a in ascending order.
Input
The first line contains a single integer t (1 ≤ t ≤ 2000) — the number of test cases.
The first line of the test case contains a single integer n (3 ≤ n ≤ 50) — the number of elements in the permutation.
The second line of the test case contains n distinct integers from 1 to n — the given permutation a.
Output
For each test case, output a single integer — the minimum number of operations described above to sort the array a in ascending order.
Example
Input
3
4
1 3 2 4
3
1 2 3
5
2 1 4 5 3
Output
1
0
2
Note
In the explanations, a[i, j] defines the subarray of a that starts from the i-th element and ends with the j-th element.
In the first test case of the example, you can select the subarray a[2, 3] and swap the elements in it.
In the second test case of the example, the permutation is already sorted, so you don't need to apply any operations.
In the third test case of the example, you can select the subarray a[3, 5] and reorder the elements in it so a becomes [2, 1, 3, 4, 5], and then select the subarray a[1, 2] and swap the elements in it, so a becomes [1, 2, 3, 4, 5].
### Response
```cpp
#include<iostream>
#include<cstdio>
using namespace std;
int T,n,a[100],ans;
int main()
{
scanf("%d",&T);
while(T--)
{
ans=0;
scanf("%d",&n);
for(int k=1;k<=n;k++) scanf("%d",&a[k]);
for(int i=1;i<=n;i++) if(a[i]!=i) ans=1;
if(a[1]!=1 && a[n]!=n) ans=2;
if(a[1]==n && a[n]==1) ans=3;
printf("%d\n",ans);
}
return 0;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
An array of positive integers a1, a2, ..., an is given. Let us consider its arbitrary subarray al, al + 1..., ar, where 1 ≤ l ≤ r ≤ n. For every positive integer s denote by Ks the number of occurrences of s into the subarray. We call the power of the subarray the sum of products Ks·Ks·s for every positive integer s. The sum contains only finite number of nonzero summands as the number of different values in the array is indeed finite.
You should calculate the power of t given subarrays.
Input
First line contains two integers n and t (1 ≤ n, t ≤ 200000) — the array length and the number of queries correspondingly.
Second line contains n positive integers ai (1 ≤ ai ≤ 106) — the elements of the array.
Next t lines contain two positive integers l, r (1 ≤ l ≤ r ≤ n) each — the indices of the left and the right ends of the corresponding subarray.
Output
Output t lines, the i-th line of the output should contain single positive integer — the power of the i-th query subarray.
Please, do not use %lld specificator to read or write 64-bit integers in C++. It is preferred to use cout stream (also you may use %I64d).
Examples
Input
3 2
1 2 1
1 2
1 3
Output
3
6
Input
8 3
1 1 2 2 1 3 1 1
2 7
1 6
2 7
Output
20
20
20
Note
Consider the following array (see the second sample) and its [2, 7] subarray (elements of the subarray are colored):
<image> Then K1 = 3, K2 = 2, K3 = 1, so the power is equal to 32·1 + 22·2 + 12·3 = 20.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 10;
const int INF = 0x3f3f3f3f;
const int P = 131;
int block, n, m, a[N];
long long cnt[N], ans[N];
long long sum;
struct node {
int l, r, id;
} Q[N];
bool cmp(node &a, struct node &b) {
if (a.l / block != b.l / block) return a.l < b.l;
return a.r < b.r;
}
void add(int x) {
sum -= (long long)cnt[a[x]] * cnt[a[x]] * a[x];
cnt[a[x]]++;
sum += (long long)cnt[a[x]] * cnt[a[x]] * a[x];
}
void del(int x) {
sum -= (long long)cnt[a[x]] * cnt[a[x]] * a[x];
cnt[a[x]]--;
sum += (long long)cnt[a[x]] * cnt[a[x]] * a[x];
}
void solve() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &Q[i].l, &Q[i].r);
Q[i].id = i;
}
block = sqrt(m * 2 / 3.0);
sort(Q + 1, Q + 1 + m, cmp);
int l = 1, r = 0;
for (int i = 1; i <= m; i++) {
while (l < Q[i].l) del(l++);
while (l > Q[i].l) add(--l);
while (r < Q[i].r) add(++r);
while (r > Q[i].r) del(r--);
ans[Q[i].id] = sum;
}
for (int i = 1; i <= m; i++) printf("%lld\n", ans[i]);
}
int main() {
int t = 1;
while (t--) {
solve();
}
return 0;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
This problem is given in two editions, which differ exclusively in the constraints on the number n.
You are given an array of integers a[1], a[2], ..., a[n]. A block is a sequence of contiguous (consecutive) elements a[l], a[l+1], ..., a[r] (1 ≤ l ≤ r ≤ n). Thus, a block is defined by a pair of indices (l, r).
Find a set of blocks (l_1, r_1), (l_2, r_2), ..., (l_k, r_k) such that:
* They do not intersect (i.e. they are disjoint). Formally, for each pair of blocks (l_i, r_i) and (l_j, r_j) where i ≠ j either r_i < l_j or r_j < l_i.
* For each block the sum of its elements is the same. Formally, $$$a[l_1]+a[l_1+1]+...+a[r_1]=a[l_2]+a[l_2+1]+...+a[r_2]= ... = a[l_k]+a[l_k+1]+...+a[r_k].$$$
* The number of the blocks in the set is maximum. Formally, there does not exist a set of blocks (l_1', r_1'), (l_2', r_2'), ..., (l_{k'}', r_{k'}') satisfying the above two requirements with k' > k.
<image> The picture corresponds to the first example. Blue boxes illustrate blocks.
Write a program to find such a set of blocks.
Input
The first line contains integer n (1 ≤ n ≤ 1500) — the length of the given array. The second line contains the sequence of elements a[1], a[2], ..., a[n] (-10^5 ≤ a_i ≤ 10^5).
Output
In the first line print the integer k (1 ≤ k ≤ n). The following k lines should contain blocks, one per line. In each line print a pair of indices l_i, r_i (1 ≤ l_i ≤ r_i ≤ n) — the bounds of the i-th block. You can print blocks in any order. If there are multiple answers, print any of them.
Examples
Input
7
4 1 2 2 1 5 3
Output
3
7 7
2 3
4 5
Input
11
-5 -4 -3 -2 -1 0 1 2 3 4 5
Output
2
3 4
1 1
Input
4
1 1 1 1
Output
4
4 4
1 1
2 2
3 3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
int a[n + 1], partial[n + 1];
partial[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
partial[i] = partial[i - 1] + a[i];
}
map<int, vector<pair<int, int>>> block;
for (int i = 1; i <= n; i++)
for (int j = 0; j <= i - 1; j++) {
int sum = partial[i] - partial[j];
block[sum].push_back({j + 1, i});
}
int mx = 0, mxi = 0;
for (auto x : block) {
int ptr = 0, count = 0;
for (auto i : x.second)
if (i.first > ptr) {
count++;
ptr = i.second;
}
if (count > mx) {
mx = count;
mxi = x.first;
}
}
int ptr = 0;
cout << mx << endl;
for (auto i : block[mxi])
if (i.first > ptr) {
cout << i.first << " " << i.second << endl;
ptr = i.second;
}
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
You are given n points on the straight line — the positions (x-coordinates) of the cities and m points on the same line — the positions (x-coordinates) of the cellular towers. All towers work in the same way — they provide cellular network for all cities, which are located at the distance which is no more than r from this tower.
Your task is to find minimal r that each city has been provided by cellular network, i.e. for each city there is at least one cellular tower at the distance which is no more than r.
If r = 0 then a tower provides cellular network only for the point where it is located. One tower can provide cellular network for any number of cities, but all these cities must be at the distance which is no more than r from this tower.
Input
The first line contains two positive integers n and m (1 ≤ n, m ≤ 105) — the number of cities and the number of cellular towers.
The second line contains a sequence of n integers a1, a2, ..., an ( - 109 ≤ ai ≤ 109) — the coordinates of cities. It is allowed that there are any number of cities in the same point. All coordinates ai are given in non-decreasing order.
The third line contains a sequence of m integers b1, b2, ..., bm ( - 109 ≤ bj ≤ 109) — the coordinates of cellular towers. It is allowed that there are any number of towers in the same point. All coordinates bj are given in non-decreasing order.
Output
Print minimal r so that each city will be covered by cellular network.
Examples
Input
3 2
-2 2 4
-3 0
Output
4
Input
5 3
1 5 10 14 17
4 11 15
Output
3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9 + 7;
const int N = 1e5 + 10;
int main() {
int n, m;
cin >> n >> m;
vector<long long> v1(n + 2), v2(m + 2);
for (int i = 1; i <= n; i++) cin >> v1[i];
for (int i = 1; i <= m; i++) cin >> v2[i];
v1[0] = v2[0] = -INF * INF;
v1[n + 1] = v2[m + 1] = INF * INF;
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
n = v1.size();
m = v2.size();
int r = 0;
int ans = 0;
for (auto &x : v1) {
while (r < m - 1) {
if (v2[r] <= x && x <= v2[r + 1]) break;
r++;
}
int tmp = min(abs(x - v2[r]), abs(x - v2[r + 1]));
ans = max(tmp, ans);
}
cout << ans << endl;
return 0;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
Arseny likes to organize parties and invite people to it. However, not only friends come to his parties, but friends of his friends, friends of friends of his friends and so on. That's why some of Arseny's guests can be unknown to him. He decided to fix this issue using the following procedure.
At each step he selects one of his guests A, who pairwise introduces all of his friends to each other. After this action any two friends of A become friends. This process is run until all pairs of guests are friends.
Arseny doesn't want to spend much time doing it, so he wants to finish this process using the minimum number of steps. Help Arseny to do it.
Input
The first line contains two integers n and m (1 ≤ n ≤ 22; <image>) — the number of guests at the party (including Arseny) and the number of pairs of people which are friends.
Each of the next m lines contains two integers u and v (1 ≤ u, v ≤ n; u ≠ v), which means that people with numbers u and v are friends initially. It's guaranteed that each pair of friends is described not more than once and the graph of friendship is connected.
Output
In the first line print the minimum number of steps required to make all pairs of guests friends.
In the second line print the ids of guests, who are selected at each step.
If there are multiple solutions, you can output any of them.
Examples
Input
5 6
1 2
1 3
2 3
2 5
3 4
4 5
Output
2
2 3
Input
4 4
1 2
1 3
1 4
3 4
Output
1
1
Note
In the first test case there is no guest who is friend of all other guests, so at least two steps are required to perform the task. After second guest pairwise introduces all his friends, only pairs of guests (4, 1) and (4, 2) are not friends. Guest 3 or 5 can introduce them.
In the second test case guest number 1 is a friend of all guests, so he can pairwise introduce all guests in one step.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int f[23][23], n, m, ans1, ans2, maxsta;
bool vis[1 << 23];
void dfs(int x, int sta) {
vis[sta] = 1;
if (x >= ans1) return;
if (clock() >= 0.5 * CLOCKS_PER_SEC) return;
int flag = 1;
for (int i = 0; i < n && flag; i++)
if (f[x][i] != (1 << n) - 1) flag = 0;
if (flag) {
ans1 = x, ans2 = sta;
return;
} else {
for (int i = 0; i < n; i++) {
if (vis[sta | (1 << i)]) continue;
for (int j = 0; j < n; j++) {
f[x + 1][j] = ((f[x][i] >> j) & 1 ? (f[x][i] | f[x][j]) : f[x][j]);
}
dfs(x + 1, sta | (1 << i));
}
}
}
int main() {
scanf("%d%d", &n, &m);
memset(vis, 0, sizeof(vis));
for (int i = 0; i < n; i++) f[0][i] = (1 << i);
for (int i = 0, x, y; i < m; i++) {
scanf("%d%d", &x, &y);
x--;
y--;
f[0][x] |= (1 << y);
f[0][y] |= (1 << x);
}
ans1 = 100, ans2 = 0;
clock();
dfs(0, 0);
printf("%d\n", ans1);
for (int i = 0; i < n; i++) {
if ((ans2 >> i) & 1) {
printf("%d", i + 1);
ans1--;
if (ans1 == 0)
printf("\n");
else
printf(" ");
}
}
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
You are given a tree with N vertices. The vertices are numbered 0 through N-1, and the edges are numbered 1 through N-1. Edge i connects Vertex x_i and y_i, and has a value a_i. You can perform the following operation any number of times:
* Choose a simple path and a non-negative integer x, then for each edge e that belongs to the path, change a_e by executing a_e ← a_e ⊕ x (⊕ denotes XOR).
Your objective is to have a_e = 0 for all edges e. Find the minimum number of operations required to achieve it.
Constraints
* 2 ≤ N ≤ 10^5
* 0 ≤ x_i,y_i ≤ N-1
* 0 ≤ a_i ≤ 15
* The given graph is a tree.
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
x_1 y_1 a_1
x_2 y_2 a_2
:
x_{N-1} y_{N-1} a_{N-1}
Output
Find the minimum number of operations required to achieve the objective.
Examples
Input
5
0 1 1
0 2 3
0 3 6
3 4 4
Output
3
Input
2
1 0 0
Output
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int Nmax = 1e5 + 5;
int i, dp[1<<15], j, x, y, z, n, m, xr, val[Nmax], cnt[20], ans;
vector<int> v;
int main()
{
// freopen("input", "r", stdin);
cin.sync_with_stdio(false);
cin >> n;
for(i=1; i<n; ++i)
{
cin >> x >> y >> z;
val[x] ^= z; val[y] ^= z;
}
for(i=0; i<n; ++i) cnt[val[i]]++;
ans = cnt[0];
for(i=1; i<=15; ++i)
{
ans += cnt[i] / 2;
if(cnt[i] & 1) v.push_back(i);
}
m = v.size();
if(m)
{
for(i=0; i<(1<<m); ++i)
{
xr = 0;
for(j=0; j<m; ++j)
if(i&(1<<j)) xr ^= v[j];
if(!xr) dp[i] = 1;
else
{
dp[i] = -1e9;
continue;
}
for(j=i&(i-1); j; j = i&(j-1))
dp[i] = max(dp[i], dp[j] + dp[i^j]);
}
ans += dp[i-1];
}
ans = n - ans;
cout << ans << '\n';;
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Andre has very specific tastes. Recently he started falling in love with arrays.
Andre calls an nonempty array b good, if sum of its elements is divisible by the length of this array. For example, array [2, 3, 1] is good, as sum of its elements — 6 — is divisible by 3, but array [1, 1, 2, 3] isn't good, as 7 isn't divisible by 4.
Andre calls an array a of length n perfect if the following conditions hold:
* Every nonempty subarray of this array is good.
* For every i (1 ≤ i ≤ n), 1 ≤ a_i ≤ 100.
Given a positive integer n, output any perfect array of length n. We can show that for the given constraints such an array always exists.
An array c is a subarray of an array d if c can be obtained from d by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 100). Description of the test cases follows.
The first and only line of every test case contains a single integer n (1 ≤ n ≤ 100).
Output
For every test, output any perfect array of length n on a separate line.
Example
Input
3
1
2
4
Output
24
19 33
7 37 79 49
Note
Array [19, 33] is perfect as all 3 its subarrays: [19], [33], [19, 33], have sums divisible by their lengths, and therefore are good.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n;
scanf("%d", &t);
while (t--) {
scanf("%d\n", &n);
for (int a = 0; a < n; a++) {
printf("%d ", 1);
}
printf("\n");
}
return 0;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
Anu has created her own function f: f(x, y) = (x | y) - y where | denotes the [bitwise OR operation](https://en.wikipedia.org/wiki/Bitwise_operation#OR). For example, f(11, 6) = (11|6) - 6 = 15 - 6 = 9. It can be proved that for any nonnegative numbers x and y value of f(x, y) is also nonnegative.
She would like to research more about this function and has created multiple problems for herself. But she isn't able to solve all of them and needs your help. Here is one of these problems.
A value of an array [a_1, a_2, ..., a_n] is defined as f(f(... f(f(a_1, a_2), a_3), ... a_{n-1}), a_n) (see notes). You are given an array with not necessarily distinct elements. How should you reorder its elements so that the value of the array is maximal possible?
Input
The first line contains a single integer n (1 ≤ n ≤ 10^5).
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 10^9). Elements of the array are not guaranteed to be different.
Output
Output n integers, the reordering of the array with maximum value. If there are multiple answers, print any.
Examples
Input
4
4 0 11 6
Output
11 6 4 0
Input
1
13
Output
13
Note
In the first testcase, value of the array [11, 6, 4, 0] is f(f(f(11, 6), 4), 0) = f(f(9, 4), 0) = f(9, 0) = 9.
[11, 4, 0, 6] is also a valid answer.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int ioo = INT_MAX;
long long Loo = LONG_LONG_MAX;
long long power(long long fa, long long n) {
long long k = 1;
while (n) {
if (n % 2) k = (k * fa) % (long long)(1000000000 + 7);
fa = (fa * fa) % (long long)(1000000000 + 7);
n /= 2;
}
return k;
}
int a[100005];
int cnt[30];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr), cout.tie(nullptr);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
for (int k = 0; k <= 29; k++) {
if ((a[i] & (1 << k)) != 0) cnt[k]++;
}
}
int ans = 0, idx = 1;
for (int i = 1; i <= n; i++) {
int in = a[i];
int cur = 0;
for (int k = 0; k <= 29; k++) {
if ((in & (1 << k)) != 0 && cnt[k] == 1) cur |= (1 << k);
}
if (cur > ans) ans = cur, idx = i;
}
cout << a[idx] << " ";
for (int i = 1; i <= n; i++)
if (i != idx) cout << a[i] << " ";
return 0;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
There are N Reversi pieces arranged in a row. (A Reversi piece is a disc with a black side and a white side.) The state of each piece is represented by a string S of length N. If S_i=`B`, the i-th piece from the left is showing black; If S_i=`W`, the i-th piece from the left is showing white.
Consider performing the following operation:
* Choose i (1 \leq i < N) such that the i-th piece from the left is showing black and the (i+1)-th piece from the left is showing white, then flip both of those pieces. That is, the i-th piece from the left is now showing white and the (i+1)-th piece from the left is now showing black.
Find the maximum possible number of times this operation can be performed.
Constraints
* 1 \leq |S| \leq 2\times 10^5
* S_i=`B` or `W`
Input
Input is given from Standard Input in the following format:
S
Output
Print the maximum possible number of times the operation can be performed.
Examples
Input
BBW
Output
2
Input
BWBWBW
Output
6
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
char ch;
long ans, b;
int main() {
while(cin >> ch) {
if (ch == 'B') b++;
else ans += b;
}
cout << ans << endl;
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
You, the mighty Blackout, are standing in the upper-left (0,0) corner of NxM matrix. You must move either right or down each second.
There are K transformers jumping around the matrix in the following way. Each transformer starts jumping from position (x,y), at time t, and jumps to the next position each second. The x-axes grows downwards, and y-axes grows to the right. The order of jumping positions is defined as {(x,y),(x+d,y-d),(x+d,y),(x,y+d)}, and is periodic. Before time t transformer is not in the matrix.
You want to arrive to the bottom-right corner (N-1,M-1), while slaying transformers and losing the least possible amount of energy. When you meet the transformer (or more of them) in the matrix field, you must kill them all, and you lose the sum of the energy amounts required to kill each transformer.
After the transformer is killed, he of course stops jumping, falls into the abyss and leaves the matrix world. Output minimum possible amount of energy wasted.
Input
In the first line, integers N,M (1 ≤ N, M ≤ 500), representing size of the matrix, and K (0 ≤ K ≤ 5*10^5) , the number of jumping transformers.
In next K lines, for each transformer, numbers x, y, d (d ≥ 1), t (0 ≤ t ≤ N+M-2), and e (0 ≤ e ≤ 10^9), representing starting coordinates of transformer, jumping positions distance in pattern described above, time when transformer starts jumping, and energy required to kill it.
It is guaranteed that all 4 of jumping points of the transformers are within matrix coordinates
Output
Print single integer, the minimum possible amount of energy wasted, for Blackout to arrive at bottom-right corner.
Example
Input
3 3 5
0 1 1 0 7
1 1 1 0 10
1 1 1 1 2
1 1 1 2 2
0 1 1 2 3
Output
9
Note
If Blackout takes the path from (0, 0) to (2, 0), and then from (2, 0) to (2, 2) he will need to kill the first and third transformer for a total energy cost of 9. There exists no path with less energy value.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXH = 500;
const int MAXW = 500;
const int MAXGUARD = 500000;
int h, w, nguard;
int gx[MAXGUARD], gy[MAXGUARD], gd[MAXGUARD], gt[MAXGUARD], ge[MAXGUARD];
long long cost[MAXH][MAXW];
vector<pair<int, int>> horsave[MAXH][MAXW];
vector<pair<int, int>> versave[MAXH][MAXW];
long long hordp[MAXW][MAXW], nhordp[MAXW][MAXW];
long long verdp[MAXW][MAXH], nverdp[MAXW][MAXH];
long long chorsave[MAXW], cversave[MAXH];
long long solve() {
for (int x = (0); x < (h); ++x)
for (int y = (0); y < (w); ++y) cost[x][y] = 0;
for (int x = (0); x < (h); ++x)
for (int y = (0); y < (w); ++y) horsave[x][y].clear();
for (int x = (0); x < (h); ++x)
for (int y = (0); y < (w); ++y) versave[x][y].clear();
for (int i = (0); i < (nguard); ++i) {
int ax = gx[i], ay = gy[i], at = gt[i];
int bx = gx[i] + gd[i], by = gy[i] - gd[i], bt = gt[i] + 1;
int cx = gx[i] + gd[i], cy = gy[i], ct = gt[i] + 2;
int dx = gx[i], dy = gy[i] + gd[i], dt = gt[i] + 3;
bool hita = false;
if ((ax + ay) % 4 == at % 4 && at <= ax + ay) hita = true, at = ax + ay;
bool hitb = false;
if ((bx + by) % 4 == bt % 4 && bt <= bx + by) hitb = true, bt = bx + by;
bool hitc = false;
if ((cx + cy) % 4 == ct % 4 && ct <= cx + cy) hitc = true, ct = cx + cy;
bool hitd = false;
if ((dx + dy) % 4 == dt % 4 && dt <= dx + dy) hitd = true, dt = dx + dy;
if (hita) cost[ax][ay] += ge[i];
if (hitb) cost[bx][by] += ge[i];
if (hitc) {
cost[cx][cy] += ge[i];
if (hita) versave[cx][cy].push_back(make_pair(ax, ge[i]));
if (hitb) horsave[cx][cy].push_back(make_pair(by, ge[i]));
}
if (hitd) {
cost[dx][dy] += ge[i];
if (hita) horsave[dx][dy].push_back(make_pair(ay, ge[i]));
}
}
for (int x = (0); x < (h); ++x) {
for (int y = (0); y < (w); ++y) {
for (int k = (0); k <= (y); ++k) chorsave[k] = 0;
for (int i = (0); i < (((int)(horsave[x][y]).size())); ++i)
chorsave[horsave[x][y][i].first] += horsave[x][y][i].second;
for (int k = y; k > 0; --k) chorsave[k - 1] += chorsave[k];
for (int k = (0); k <= (x); ++k) cversave[k] = 0;
for (int i = (0); i < (((int)(versave[x][y]).size())); ++i)
cversave[versave[x][y][i].first] += versave[x][y][i].second;
for (int k = x; k > 0; --k) cversave[k - 1] += cversave[k];
nhordp[y][y] = x == 0 && y == 0 ? cost[x][y] : LLONG_MAX;
for (int k = (0); k < (x); ++k)
if (verdp[y][k] != LLONG_MAX)
nhordp[y][y] =
min(nhordp[y][y], verdp[y][k] + cost[x][y] - cversave[k]);
for (int k = (0); k < (y); ++k)
nhordp[y][k] = nhordp[y - 1][k] == LLONG_MAX
? LLONG_MAX
: nhordp[y - 1][k] + cost[x][y] - chorsave[k];
nverdp[y][x] = x == 0 && y == 0 ? cost[x][y] : LLONG_MAX;
for (int k = (0); k < (y); ++k)
if (nhordp[y - 1][k] != LLONG_MAX)
nverdp[y][x] =
min(nverdp[y][x], nhordp[y - 1][k] + cost[x][y] - chorsave[k]);
for (int k = (0); k < (x); ++k)
nverdp[y][k] = verdp[y][k] == LLONG_MAX
? LLONG_MAX
: verdp[y][k] + cost[x][y] - cversave[k];
}
for (int y = (0); y < (w); ++y)
for (int k = (0); k <= (y); ++k) hordp[y][k] = nhordp[y][k];
for (int y = (0); y < (w); ++y)
for (int k = (0); k <= (x); ++k) verdp[y][k] = nverdp[y][k];
}
long long ret = LLONG_MAX;
for (int k = (0); k < (w); ++k) ret = min(ret, hordp[w - 1][k]);
for (int k = (0); k < (h); ++k) ret = min(ret, verdp[w - 1][k]);
return ret;
}
void run() {
scanf("%d%d%d", &h, &w, &nguard);
for (int i = (0); i < (nguard); ++i)
scanf("%d%d%d%d%d", &gx[i], &gy[i], &gd[i], >[i], &ge[i]);
printf("%lld\n", solve());
}
int main() {
run();
return 0;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
Snuke loves colorful balls. He has a total of N×K balls, K in each of his favorite N colors. The colors are numbered 1 through N.
He will arrange all of the balls in a row from left to right, in arbitrary order. Then, for each of the N colors, he will paint the leftmost ball of that color into color 0, a color different from any of the N original colors.
After painting, how many sequences of the colors of the balls are possible? Find this number modulo 10^9+7.
Constraints
* 1≤N,K≤2,000
Input
The input is given from Standard Input in the following format:
N K
Output
Print the number of the possible sequences of the colors of the balls after painting, modulo 10^9+7.
Examples
Input
2 2
Output
4
Input
3 1
Output
1
Input
2 3
Output
14
Input
2000 2000
Output
546381702
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
const int N=2e3+7,p=1e9+7;
int n,k,dp[N][N]; long long fac[N*N],ifac[N*N];
inline int pows(long long u,int v){
long long ans=1; while(v>0) {if(v&1) ans=ans*u%p; u=u*u%p,v=v>>1;} return ans;
}
inline long long getans(int a,int b){
return fac[a]*ifac[b]%p*ifac[a-b]%p;
}
int main(){
cin>>n>>k,fac[0]=ifac[0]=1;
for(int i=1;i<=n*k;i++) fac[i]=fac[i-1]*i%p,ifac[i]=pows(fac[i],p-2); dp[0][0]=1;
for(int i=1;i<=n;i++)
for(int j=0;j<=i;j++){
if(j>0) dp[i][j]=(dp[i][j-1]*getans(n*k-(k-1)*(j-1)-i-1,k-2)+dp[i-1][j])%p;
else dp[i][j]=dp[i-1][j];
}
if(k==1) cout<<1<<endl; else cout<<dp[n][n]*fac[n]%p<<endl;
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
You are an immigration officer in the Kingdom of AtCoder. The document carried by an immigrant has some number of integers written on it, and you need to check whether they meet certain criteria.
According to the regulation, the immigrant should be allowed entry to the kingdom if and only if the following condition is satisfied:
* All even numbers written on the document are divisible by 3 or 5.
If the immigrant should be allowed entry according to the regulation, output `APPROVED`; otherwise, print `DENIED`.
Constraints
* All values in input are integers.
* 1 \leq N \leq 100
* 1 \leq A_i \leq 1000
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 \dots A_N
Output
If the immigrant should be allowed entry according to the regulation, print `APPROVED`; otherwise, print `DENIED`.
Examples
Input
5
6 7 9 10 31
Output
APPROVED
Input
3
28 27 24
Output
DENIED
### Response
```cpp
#include<iostream>
using namespace std;
int main(){
int N;
cin>>N;
int A[N];
for(int i=0;i<N;i++){
cin>>A[i];
if(A[i]%2==0 && (A[i]%3!=0 && A[i]%5!=0)){
cout<<"DENIED";
return 0;
}
}
cout<<"APPROVED";
return 0;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
The stardate is 1977 and the science and art of detecting Death Stars is in its infancy. Princess Heidi has received information about the stars in the nearby solar system from the Rebel spies and now, to help her identify the exact location of the Death Star, she needs to know whether this information is correct.
Two rebel spies have provided her with the maps of the solar system. Each map is an N × N grid, where each cell is either occupied by a star or empty. To see whether the information is correct, Heidi needs to know whether the two maps are of the same solar system, or if possibly one of the spies is actually an Empire double agent, feeding her false information.
Unfortunately, spies may have accidentally rotated a map by 90, 180, or 270 degrees, or flipped it along the vertical or the horizontal axis, before delivering it to Heidi. If Heidi can rotate or flip the maps so that two of them become identical, then those maps are of the same solar system. Otherwise, there are traitors in the Rebel ranks! Help Heidi find out.
Input
The first line of the input contains one number N (1 ≤ N ≤ 10) – the dimension of each map. Next N lines each contain N characters, depicting the first map: 'X' indicates a star, while 'O' indicates an empty quadrant of space. Next N lines each contain N characters, depicting the second map in the same format.
Output
The only line of output should contain the word Yes if the maps are identical, or No if it is impossible to match them by performing rotations and translations.
Examples
Input
4
XOOO
XXOO
OOOO
XXXX
XOOO
XOOO
XOXO
XOXX
Output
Yes
Input
2
XX
OO
XO
OX
Output
No
Note
In the first test, you can match the first map to the second map by first flipping the first map along the vertical axis, and then by rotating it 90 degrees clockwise.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<vector<bool> > matrix1, matrix2;
vector<vector<bool> > copy(vector<vector<bool> > matrix) {
int N = matrix.size();
vector<vector<bool> > ans(N);
for (int i = 0; i < N; i++) {
ans[i].resize(N);
for (int j = 0; j < N; j++) ans[i][j] = matrix[i][j];
}
return ans;
}
vector<vector<bool> > flip_vertical(vector<vector<bool> > matrix) {
int N = matrix.size();
vector<vector<bool> > ans(N);
for (int i = 0; i < N; i++) {
ans[i].resize(N);
for (int j = 0; j < N; j++) ans[i][j] = matrix[i][N - 1 - j];
}
return ans;
}
vector<vector<bool> > flip_horizontal(vector<vector<bool> > matrix) {
int N = matrix.size();
vector<vector<bool> > ans(N);
for (int i = 0; i < N; i++) {
ans[i].resize(N);
for (int j = 0; j < N; j++) ans[i][j] = matrix[N - 1 - i][j];
}
return ans;
}
vector<vector<bool> > rotate_90(vector<vector<bool> > matrix) {
int N = matrix.size();
vector<vector<bool> > ans(N);
for (int i = 0; i < N; i++) {
ans[i].resize(N);
for (int j = 0; j < N; j++) ans[i][j] = matrix[N - 1 - j][i];
}
return ans;
}
vector<vector<bool> > rotate_180(vector<vector<bool> > matrix) {
int N = matrix.size();
vector<vector<bool> > ans(N);
for (int i = 0; i < N; i++) {
ans[i].resize(N);
for (int j = 0; j < N; j++) ans[i][j] = matrix[j][i];
}
return ans;
}
vector<vector<bool> > rotate_270(vector<vector<bool> > matrix) {
int N = matrix.size();
vector<vector<bool> > ans(N);
for (int i = 0; i < N; i++) {
ans[i].resize(N);
for (int j = 0; j < N; j++) ans[i][j] = matrix[j][N - 1 - i];
}
return ans;
}
bool isEqual(vector<vector<bool> > matrix1, vector<vector<bool> > matrix2) {
for (int i = 0; i < matrix1.size(); i++)
for (int j = 0; j < matrix1[i].size(); j++)
if (matrix1[i][j] != matrix2[i][j]) return false;
return true;
}
void display(vector<vector<bool> > matrix) {
int N = matrix.size();
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) cout << matrix[i][j] << " ";
cout << "\n";
}
}
bool checkEquality() {
vector<vector<bool> > tmp1, tmp2;
for (int i = 0; i < 6; i++)
for (int j = 0; j < 6; j++) {
switch (i) {
case 0:
tmp1 = copy(matrix1);
break;
case 1:
tmp1 = flip_vertical(matrix1);
break;
case 2:
tmp1 = flip_horizontal(matrix1);
break;
case 3:
tmp1 = rotate_90(matrix1);
break;
case 4:
tmp1 = rotate_180(matrix1);
break;
case 5:
tmp1 = rotate_270(matrix1);
break;
}
switch (j) {
case 0:
tmp2 = copy(matrix2);
break;
case 1:
tmp2 = flip_vertical(matrix2);
break;
case 2:
tmp2 = flip_horizontal(matrix2);
break;
case 3:
tmp2 = rotate_90(matrix2);
break;
case 4:
tmp2 = rotate_180(matrix2);
break;
case 5:
tmp2 = rotate_270(matrix2);
break;
}
if (isEqual(tmp1, tmp2)) return true;
}
return false;
}
int main() {
int N;
cin >> N;
matrix1.resize(N);
matrix2.resize(N);
string str;
cin.ignore();
for (int i = 0; i < N; i++) {
cin >> str;
matrix1[i].assign(N, false);
for (int j = 0; j < N; j++)
if (str[j] == 'X') matrix1[i][j] = true;
}
for (int i = 0; i < N; i++) {
cin >> str;
matrix2[i].assign(N, false);
for (int j = 0; j < N; j++)
if (str[j] == 'X') matrix2[i][j] = true;
}
if (checkEquality())
cout << "Yes";
else
cout << "No";
cout << "\n";
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
A string t is called an anagram of the string s, if it is possible to rearrange letters in t so that it is identical to the string s. For example, the string "aab" is an anagram of the string "aba" and the string "aaa" is not.
The string t is called a substring of the string s if it can be read starting from some position in the string s. For example, the string "aba" has six substrings: "a", "b", "a", "ab", "ba", "aba".
You are given a string s, consisting of lowercase Latin letters and characters "?". You are also given a string p, consisting of lowercase Latin letters only. Let's assume that a string is good if you can obtain an anagram of the string p from it, replacing the "?" characters by Latin letters. Each "?" can be replaced by exactly one character of the Latin alphabet. For example, if the string p = «aba», then the string "a??" is good, and the string «?bc» is not.
Your task is to find the number of good substrings of the string s (identical substrings must be counted in the answer several times).
Input
The first line is non-empty string s, consisting of no more than 105 lowercase Latin letters and characters "?". The second line is non-empty string p, consisting of no more than 105 lowercase Latin letters. Please note that the length of the string p can exceed the length of the string s.
Output
Print the single number representing the number of good substrings of string s.
Two substrings are considered different in their positions of occurrence are different. Thus, if some string occurs several times, then it should be counted the same number of times.
Examples
Input
bb??x???
aab
Output
2
Input
ab?c
acb
Output
2
Note
Consider the first sample test. Here the string s has two good substrings: "b??" (after we replace the question marks we get "baa"), "???" (after we replace the question marks we get "baa").
Let's consider the second sample test. Here the string s has two good substrings: "ab?" ("?" can be replaced by "c"), "b?c" ("?" can be replaced by "a").
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long n, a[111111][27], i, j, ans, l, m, b[26];
string s, t;
int main() {
cin >> s >> t;
for (i = 0; i < t.size(); i++) b[t[i] - 97]++;
for (i = 0; i < s.size(); i++) {
if (i)
for (j = 0; j < 27; j++) a[i][j] = a[i - 1][j];
if (s[i] == '?')
a[i][26]++;
else
a[i][s[i] - 97]++;
}
long long sss = 0;
for (j = 0; j < 26; j++) {
if (a[t.size() - 1][j] > b[j])
break;
else
sss += b[j] - a[t.size() - 1][j];
}
if (j == 26 && sss <= a[t.size() - 1][26]) ans++;
l = 1;
for (i = t.size(); i < s.size(); i++, l++) {
sss = 0;
for (j = 0; j < 26; j++) {
if (a[i][j] - a[l - 1][j] > b[j])
break;
else
sss += b[j] - a[i][j] + a[l - 1][j];
}
if (j == 26 && sss <= a[i][26] - a[l - 1][26]) ans++;
}
cout << ans;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
You are given integers N and M.
Consider a sequence a of length N consisting of positive integers such that a_1 + a_2 + ... + a_N = M. Find the maximum possible value of the greatest common divisor of a_1, a_2, ..., a_N.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^5
* N \leq M \leq 10^9
Input
Input is given from Standard Input in the following format:
N M
Output
Print the maximum possible value of the greatest common divisor of a sequence a_1, a_2, ..., a_N that satisfies the condition.
Examples
Input
3 14
Output
2
Input
10 123
Output
3
Input
100000 1000000000
Output
10000
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,m,ans;
cin>>n>>m;
for(int i=m/n;i>=0;i--){
if(m%i==0){
ans=i;
break;
}
}
cout<<ans<<endl;
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
You are given two integer sequences of length N: a_1,a_2,..,a_N and b_1,b_2,..,b_N. Determine if we can repeat the following operation zero or more times so that the sequences a and b become equal.
Operation: Choose two integers i and j (possibly the same) between 1 and N (inclusive), then perform the following two actions simultaneously:
* Add 2 to a_i.
* Add 1 to b_j.
Constraints
* 1 ≤ N ≤ 10 000
* 0 ≤ a_i,b_i ≤ 10^9 (1 ≤ i ≤ N)
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
a_1 a_2 .. a_N
b_1 b_2 .. b_N
Output
If we can repeat the operation zero or more times so that the sequences a and b become equal, print `Yes`; otherwise, print `No`.
Examples
Input
3
1 2 3
5 2 2
Output
Yes
Input
5
3 1 4 1 5
2 7 1 8 2
Output
No
Input
5
2 7 1 8 2
3 1 4 1 5
Output
No
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
#define N 12000
int n,a[N],b[N];
long long cnt;
int main(){
scanf("%d",&n);
for (int i=1;i<=n;i++) scanf("%d",&a[i]);
for (int i=1;i<=n;i++) scanf("%d",&b[i]);
for (int i=1;i<=n;i++){
if (a[i]<b[i]) cnt+=(b[i]-a[i]+1)/2,a[i]+=(b[i]-a[i]+1)/2*2;
if (a[i]>b[i]) cnt-=a[i]-b[i];
}
if (cnt>=0) puts("Yes");
else puts("No");
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
Vasya has got n books, numbered from 1 to n, arranged in a stack. The topmost book has number a_1, the next one — a_2, and so on. The book at the bottom of the stack has number a_n. All numbers are distinct.
Vasya wants to move all the books to his backpack in n steps. During i-th step he wants to move the book number b_i into his backpack. If the book with number b_i is in the stack, he takes this book and all the books above the book b_i, and puts them into the backpack; otherwise he does nothing and begins the next step. For example, if books are arranged in the order [1, 2, 3] (book 1 is the topmost), and Vasya moves the books in the order [2, 1, 3], then during the first step he will move two books (1 and 2), during the second step he will do nothing (since book 1 is already in the backpack), and during the third step — one book (the book number 3). Note that b_1, b_2, ..., b_n are distinct.
Help Vasya! Tell him the number of books he will put into his backpack during each step.
Input
The first line contains one integer n~(1 ≤ n ≤ 2 ⋅ 10^5) — the number of books in the stack.
The second line contains n integers a_1, a_2, ..., a_n~(1 ≤ a_i ≤ n) denoting the stack of books.
The third line contains n integers b_1, b_2, ..., b_n~(1 ≤ b_i ≤ n) denoting the steps Vasya is going to perform.
All numbers a_1 ... a_n are distinct, the same goes for b_1 ... b_n.
Output
Print n integers. The i-th of them should be equal to the number of books Vasya moves to his backpack during the i-th step.
Examples
Input
3
1 2 3
2 1 3
Output
2 0 1
Input
5
3 1 4 2 5
4 5 1 3 2
Output
3 2 0 0 0
Input
6
6 5 4 3 2 1
6 5 3 4 2 1
Output
1 1 2 0 1 1
Note
The first example is described in the statement.
In the second example, during the first step Vasya will move the books [3, 1, 4]. After that only books 2 and 5 remain in the stack (2 is above 5). During the second step Vasya will take the books 2 and 5. After that the stack becomes empty, so during next steps Vasya won't move any books.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long ind[200001], arr[200001];
int main() {
ios::sync_with_stdio(false);
long long i, j, k, n, l = 1, a;
cin >> n;
for (i = 0; i < n; i++) {
cin >> arr[i];
ind[arr[i]] = i + 1;
}
for (i = 0; i < n; i++) {
cin >> a;
if (ind[a] >= l) {
cout << ind[a] - l + 1 << " ";
l = ind[a] + 1;
} else
cout << 0 << " ";
}
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
Let’s define a grid to be a set of tiles with 2 rows and 13 columns. Each tile has an English letter written in it. The letters don't have to be unique: there might be two or more tiles with the same letter written on them. Here is an example of a grid:
ABCDEFGHIJKLM
NOPQRSTUVWXYZ
We say that two tiles are adjacent if they share a side or a corner. In the example grid above, the tile with the letter 'A' is adjacent only to the tiles with letters 'B', 'N', and 'O'. A tile is not adjacent to itself.
A sequence of tiles is called a path if each tile in the sequence is adjacent to the tile which follows it (except for the last tile in the sequence, which of course has no successor). In this example, "ABC" is a path, and so is "KXWIHIJK". "MAB" is not a path because 'M' is not adjacent to 'A'. A single tile can be used more than once by a path (though the tile cannot occupy two consecutive places in the path because no tile is adjacent to itself).
You’re given a string s which consists of 27 upper-case English letters. Each English letter occurs at least once in s. Find a grid that contains a path whose tiles, viewed in the order that the path visits them, form the string s. If there’s no solution, print "Impossible" (without the quotes).
Input
The only line of the input contains the string s, consisting of 27 upper-case English letters. Each English letter occurs at least once in s.
Output
Output two lines, each consisting of 13 upper-case English characters, representing the rows of the grid. If there are multiple solutions, print any of them. If there is no solution print "Impossible".
Examples
Input
ABCDEFGHIJKLMNOPQRSGTUVWXYZ
Output
YXWVUTGHIJKLM
ZABCDEFSRQPON
Input
BUVTYZFQSNRIWOXXGJLKACPEMDH
Output
Impossible
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int i, j, x, y, c, l, cnt[26];
string s, str;
char ans[13][2];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
memset(cnt, 0, sizeof(cnt));
cin >> s;
for (i = 0; i < 27; i++) cnt[s[i] - 'A']++;
x = y = -1;
for (i = 0; i < 27; i++) {
if (cnt[s[i] - 'A'] > 1) {
if (x == -1)
x = i;
else
y = i;
}
}
if (y - x == 1) {
cout << "Impossible\n";
return 0;
}
c = (y - x - 1) / 2;
if ((y - x - 1) % 2 == 0) {
j = x + 1;
for (i = 12 - c + 1; i <= 12; i++) {
ans[i][0] = s[j];
j++;
}
for (i = 12; i >= 12 - c + 1; i--) {
ans[i][1] = s[j];
j++;
}
ans[i][0] = s[j];
str = "";
if (y + 1 < 27) str += (s.substr(y + 1));
if (x > 0) str += s.substr(0, x);
l = str.length();
i--;
j = 0;
while (i >= 0 && j < l) {
ans[i][0] = str[j];
j++;
i--;
}
i = 0;
while (j < l) {
ans[i][1] = str[j];
j++;
i++;
}
} else {
j = x + 1;
for (i = 12 - c + 1; i <= 12; i++) {
ans[i][0] = s[j];
j++;
}
for (i = 12; i >= 12 - c + 1; i--) {
ans[i][1] = s[j];
j++;
}
ans[i][1] = s[j];
ans[i][0] = s[y];
str = "";
if (y + 1 < 27) str += s.substr(y + 1);
if (x > 0) str += s.substr(0, x);
l = str.length();
i--;
j = 0;
while (i >= 0 && j < l) {
ans[i][0] = str[j];
j++;
i--;
}
i = 0;
while (j < l) {
ans[i][1] = str[j];
j++;
i++;
}
}
for (i = 0; i < 2; i++) {
for (j = 0; j < 13; j++) cout << ans[j][i];
cout << "\n";
}
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
You are given a rectangular matrix of size n × m consisting of integers from 1 to 2 ⋅ 10^5.
In one move, you can:
* choose any element of the matrix and change its value to any integer between 1 and n ⋅ m, inclusive;
* take any column and shift it one cell up cyclically (see the example of such cyclic shift below).
A cyclic shift is an operation such that you choose some j (1 ≤ j ≤ m) and set a_{1, j} := a_{2, j}, a_{2, j} := a_{3, j}, ..., a_{n, j} := a_{1, j} simultaneously.
<image> Example of cyclic shift of the first column
You want to perform the minimum number of moves to make this matrix look like this:
<image>
In other words, the goal is to obtain the matrix, where a_{1, 1} = 1, a_{1, 2} = 2, ..., a_{1, m} = m, a_{2, 1} = m + 1, a_{2, 2} = m + 2, ..., a_{n, m} = n ⋅ m (i.e. a_{i, j} = (i - 1) ⋅ m + j) with the minimum number of moves performed.
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 2 ⋅ 10^5, n ⋅ m ≤ 2 ⋅ 10^5) — the size of the matrix.
The next n lines contain m integers each. The number at the line i and position j is a_{i, j} (1 ≤ a_{i, j} ≤ 2 ⋅ 10^5).
Output
Print one integer — the minimum number of moves required to obtain the matrix, where a_{1, 1} = 1, a_{1, 2} = 2, ..., a_{1, m} = m, a_{2, 1} = m + 1, a_{2, 2} = m + 2, ..., a_{n, m} = n ⋅ m (a_{i, j} = (i - 1)m + j).
Examples
Input
3 3
3 2 1
1 2 3
4 5 6
Output
6
Input
4 3
1 2 3
4 5 6
7 8 9
10 11 12
Output
0
Input
3 4
1 6 3 4
5 10 7 8
9 2 11 12
Output
2
Note
In the first example, you can set a_{1, 1} := 7, a_{1, 2} := 8 and a_{1, 3} := 9 then shift the first, the second and the third columns cyclically, so the answer is 6. It can be shown that you cannot achieve a better answer.
In the second example, the matrix is already good so the answer is 0.
In the third example, it is enough to shift the second column cyclically twice to obtain a good matrix, so the answer is 2.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
vector<vector<long long> > cost(m, vector<long long>(n, n));
for (int i = (0); i < (m); ++i)
for (int j = (0); j < (n); ++j) cost[i][j] += j;
vector<vector<long long> > mat(n, vector<long long>(m));
for (int i = (0); i < (n); ++i)
for (int j = (0); j < (m); ++j) {
cin >> mat[i][j];
}
for (int j = (0); j < (m); ++j) {
for (int i = (0); i < (n); ++i) {
int val = mat[i][j];
val -= j + 1;
if (val % m == 0) {
int k = val / m;
if (k < n) {
int shft = 0;
if (k <= i)
shft = i - k;
else
shft = i + n - k;
cost[j][shft]--;
}
}
}
}
vector<long long> ans(m, n);
for (int j = (0); j < (m); ++j) {
int tot = n;
for (int i = (0); i < (n); ++i)
tot = ((tot) < (cost[j][i]) ? (tot) : (cost[j][i]));
ans[j] = ((ans[j]) < (tot) ? (ans[j]) : (tot));
}
cout << accumulate(ans.begin(), ans.end(), 0LL) << endl;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
The problem set at CODE FESTIVAL 20XX Finals consists of N problems.
The score allocated to the i-th (1≦i≦N) problem is i points.
Takahashi, a contestant, is trying to score exactly N points. For that, he is deciding which problems to solve.
As problems with higher scores are harder, he wants to minimize the highest score of a problem among the ones solved by him.
Determine the set of problems that should be solved.
Constraints
* 1≦N≦10^7
Input
The input is given from Standard Input in the following format:
N
Output
Among the sets of problems with the total score of N, find a set in which the highest score of a problem is minimum, then print the indices of the problems in the set in any order, one per line.
If there exists more than one such set, any of them will be accepted.
Examples
Input
4
Output
1
3
Input
7
Output
1
2
4
Input
1
Output
1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(){
int N;
cin >> N;
int count=1;
int sum=1;
while(sum<N){
count++;
sum+=count;
}
if(sum==N){
for(int i=1;i<=count;i++){
cout<<i<<endl;
}
}
else{
int dif=sum-N;
for(int i=1;i<=count;i++){
if(i!=dif){
cout<<i<<endl;
}
}
}
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
For a sequence a of n integers between 1 and m, inclusive, denote f(a) as the number of distinct subsequences of a (including the empty subsequence).
You are given two positive integers n and m. Let S be the set of all sequences of length n consisting of numbers from 1 to m. Compute the sum f(a) over all a in S modulo 109 + 7.
Input
The only line contains two integers n and m (1 ≤ n, m ≤ 106) — the number of elements in arrays and the upper bound for elements.
Output
Print the only integer c — the desired sum modulo 109 + 7.
Examples
Input
1 3
Output
6
Input
2 2
Output
14
Input
3 3
Output
174
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1123456;
const long long MOD = 1000 * 1000 * 1000 + 7;
long long potencia(long long m, long long n) {
if (n == 0) return 1;
if (n % 2 == 0) {
return potencia(m * m % MOD, n / 2);
}
return (potencia(m * m % MOD, n / 2) * m) % MOD;
}
int main() {
long long n, m;
scanf("%I64d %I64d", &n, &m);
long long ans = 0;
if (m == 1) {
printf("%I64d", n + 1);
return 0;
}
ans += potencia(m, n) % MOD;
long long aux = (m * potencia(m - 1, n - 1)) % MOD;
ans = (ans + aux) % MOD;
for (long long s = 1; s < n; s++) {
aux *= m;
aux %= MOD;
aux *= n - s + 1;
aux %= MOD;
aux *= potencia(s, MOD - 2);
aux %= MOD;
aux *= potencia(m - 1, MOD - 2);
aux %= MOD;
ans = (ans + aux) % MOD;
}
printf("%I64d\n", ans);
return 0;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
This problem is same as the previous one, but has larger constraints.
Aki is playing a new video game. In the video game, he will control Neko, the giant cat, to fly between planets in the Catniverse.
There are n planets in the Catniverse, numbered from 1 to n. At the beginning of the game, Aki chooses the planet where Neko is initially located. Then Aki performs k - 1 moves, where in each move Neko is moved from the current planet x to some other planet y such that:
* Planet y is not visited yet.
* 1 ≤ y ≤ x + m (where m is a fixed constant given in the input)
This way, Neko will visit exactly k different planets. Two ways of visiting planets are called different if there is some index i such that, the i-th planet visited in the first way is different from the i-th planet visited in the second way.
What is the total number of ways to visit k planets this way? Since the answer can be quite large, print it modulo 10^9 + 7.
Input
The only line contains three integers n, k and m (1 ≤ n ≤ 10^9, 1 ≤ k ≤ min(n, 12), 1 ≤ m ≤ 4) — the number of planets in the Catniverse, the number of planets Neko needs to visit and the said constant m.
Output
Print exactly one integer — the number of different ways Neko can visit exactly k planets. Since the answer can be quite large, print it modulo 10^9 + 7.
Examples
Input
3 3 1
Output
4
Input
4 2 1
Output
9
Input
5 5 4
Output
120
Input
100 1 2
Output
100
Note
In the first example, there are 4 ways Neko can visit all the planets:
* 1 → 2 → 3
* 2 → 3 → 1
* 3 → 1 → 2
* 3 → 2 → 1
In the second example, there are 9 ways Neko can visit exactly 2 planets:
* 1 → 2
* 2 → 1
* 2 → 3
* 3 → 1
* 3 → 2
* 3 → 4
* 4 → 1
* 4 → 2
* 4 → 3
In the third example, with m = 4, Neko can visit all the planets in any order, so there are 5! = 120 ways Neko can visit all the planets.
In the fourth example, Neko only visit exactly 1 planet (which is also the planet he initially located), and there are 100 ways to choose the starting planet for Neko.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n;
int m;
int k;
long long int dp[14][1 << 4];
long long int tmp[14][1 << 14];
long long int bt[208][208];
int mxt;
inline int id(int a, int b) {
mxt = max(mxt, (a << m) + b + 1);
return (a << m) + b;
}
long long int mat[208][208];
long long int ret[208][208];
int main() {
cin >> n >> k >> m;
for (int i2 = n; i2 >= n; i2--) {
int cnt = 0;
for (int i = 0; i <= k; i++) {
for (int j = 0; j < (1 << m); j++) {
int ava = 0;
for (int k = 0; k < m; k++) {
if ((j >> k) & 1) {
ava++;
}
}
ava++;
int wa = ((j << 1) & ((1 << m) - 1));
bt[id(i, wa)][id(i, j)] = 1;
wa++;
if (i + 1 <= k) {
bt[id(i + 1, wa)][id(i, j)] = ava;
}
}
}
}
for (int i = 0; i < mxt; i++) mat[i][i] = 1;
int N = n;
n = mxt;
while (N) {
if ((N & 1LL)) {
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) ret[i][j] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
for (int k = 0; k < n; k++) {
ret[i][j] += mat[i][k] * bt[k][j];
if (ret[i][j] >= 1000000007LL * 1000000007LL)
ret[i][j] -= 1000000007LL * 1000000007LL;
}
}
}
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
mat[i][j] = ret[i][j];
if (mat[i][j] >= 1000000007LL) mat[i][j] %= 1000000007LL;
}
}
N >>= 1LL;
if (N == 0) break;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) ret[i][j] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
for (int k = 0; k < n; k++) {
ret[i][j] += bt[i][k] * bt[k][j];
if (ret[i][j] >= 1000000007LL * 1000000007LL)
ret[i][j] -= 1000000007LL * 1000000007LL;
}
}
}
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
bt[i][j] = ret[i][j];
if (bt[i][j] >= 1000000007LL) bt[i][j] %= 1000000007LL;
}
}
long long int ans = 0;
for (int j = 0; j < (1 << m); j++) {
ans += mat[id(k, j)][0];
if (ans >= 1000000007LL * 1000000007LL) ans -= 1000000007LL * 1000000007LL;
}
ans %= 1000000007LL;
printf("%lld\n", ans);
return 0;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
Today, Mezo is playing a game. Zoma, a character in that game, is initially at position x = 0. Mezo starts sending n commands to Zoma. There are two possible commands:
* 'L' (Left) sets the position x: =x - 1;
* 'R' (Right) sets the position x: =x + 1.
Unfortunately, Mezo's controller malfunctions sometimes. Some commands are sent successfully and some are ignored. If the command is ignored then the position x doesn't change and Mezo simply proceeds to the next command.
For example, if Mezo sends commands "LRLR", then here are some possible outcomes (underlined commands are sent successfully):
* "LRLR" — Zoma moves to the left, to the right, to the left again and to the right for the final time, ending up at position 0;
* "LRLR" — Zoma recieves no commands, doesn't move at all and ends up at position 0 as well;
* "LRLR" — Zoma moves to the left, then to the left again and ends up in position -2.
Mezo doesn't know which commands will be sent successfully beforehand. Thus, he wants to know how many different positions may Zoma end up at.
Input
The first line contains n (1 ≤ n ≤ 10^5) — the number of commands Mezo sends.
The second line contains a string s of n commands, each either 'L' (Left) or 'R' (Right).
Output
Print one integer — the number of different positions Zoma may end up at.
Example
Input
4
LRLR
Output
5
Note
In the example, Zoma may end up anywhere between -2 and 2.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string s;
cin >> n >> s;
map<char, int> arr;
for (int i = 0; i < s.size(); i++) {
arr[s[i]]++;
}
int count = arr['L'] + arr['R'] + 1;
cout << count << endl;
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
This problem is same as the previous one, but has larger constraints.
It was a Sunday morning when the three friends Selena, Shiro and Katie decided to have a trip to the nearby power station (do not try this at home). After arriving at the power station, the cats got impressed with a large power transmission system consisting of many chimneys, electric poles, and wires. Since they are cats, they found those things gigantic.
At the entrance of the station, there is a map describing the complicated wiring system. Selena is the best at math among three friends. He decided to draw the map on the Cartesian plane. Each pole is now a point at some coordinates (x_i, y_i). Since every pole is different, all of the points representing these poles are distinct. Also, every two poles are connected with each other by wires. A wire is a straight line on the plane infinite in both directions. If there are more than two poles lying on the same line, they are connected by a single common wire.
Selena thinks, that whenever two different electric wires intersect, they may interfere with each other and cause damage. So he wonders, how many pairs are intersecting? Could you help him with this problem?
Input
The first line contains a single integer n (2 ≤ n ≤ 1000) — the number of electric poles.
Each of the following n lines contains two integers x_i, y_i (-10^4 ≤ x_i, y_i ≤ 10^4) — the coordinates of the poles.
It is guaranteed that all of these n points are distinct.
Output
Print a single integer — the number of pairs of wires that are intersecting.
Examples
Input
4
0 0
1 1
0 3
1 2
Output
14
Input
4
0 0
0 2
0 4
2 0
Output
6
Input
3
-1 -1
1 0
3 1
Output
0
Note
In the first example:
<image>
In the second example:
<image>
Note that the three poles (0, 0), (0, 2) and (0, 4) are connected by a single wire.
In the third example:
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long mabs(long long a) { return a < 0 ? -a : a; }
struct Fraction {
long long numerator;
long long denominator;
Fraction() {}
Fraction(long long numerator, long long denominator)
: numerator(numerator), denominator(denominator) {}
Fraction operator+(const Fraction &rhs) const {
long long n = numerator * rhs.denominator + rhs.numerator * denominator;
long long d = denominator * rhs.denominator;
auto ele = Fraction(n, d);
ele.reduce();
return ele;
}
Fraction operator-(const Fraction &rhs) const {
long long n = numerator * rhs.denominator - rhs.numerator * denominator;
long long d = denominator * rhs.denominator;
auto ele = Fraction(n, d);
ele.reduce();
return ele;
}
Fraction operator*(const Fraction &rhs) const {
auto ele =
Fraction(numerator * rhs.numerator, denominator * rhs.denominator);
ele.reduce();
return ele;
}
bool operator==(const Fraction &rhs) const {
return denominator == rhs.denominator && numerator == rhs.numerator;
}
bool operator!=(const Fraction &rhs) const { return !(rhs == *this); }
bool operator<(const Fraction &rhs) const {
if (denominator != rhs.denominator) return denominator < rhs.denominator;
return numerator < rhs.numerator;
}
bool operator>(const Fraction &rhs) const { return rhs < *this; }
bool operator<=(const Fraction &rhs) const { return !(rhs < *this); }
bool operator>=(const Fraction &rhs) const { return !(*this < rhs); }
void reduce() {
long long num = gcd(mabs(denominator), mabs(numerator));
if (numerator <= 0 && denominator >= 0) {
numerator *= -1;
denominator *= -1;
}
if (numerator <= 0 && denominator <= 0) {
numerator *= -1;
denominator *= -1;
}
denominator /= num;
numerator /= num;
}
friend std::ostream &operator<<(std::ostream &os, const Fraction &fraction) {
os << "denominator: " << fraction.denominator
<< " numerator: " << fraction.numerator;
return os;
}
};
long long cn2(long long n) { return n * (n - 1) / 2; }
const int N = (int)1e3 + 50;
long long x[N];
long long y[N];
int main() {
int n;
while (~scanf("%d", &n)) {
map<Fraction, int> mp;
set<pair<Fraction, Fraction> > st;
for (int i = 0; i < n; i++) {
scanf("%lld%lld", &x[i], &y[i]);
}
for (int i = 0; i < n - 1; i++) {
for (int j = i + 1; j < n; j++) {
Fraction k(y[j] - y[i], x[j] - x[i]);
Fraction b;
if (k.denominator == 0) {
k.numerator = 1;
b = Fraction(x[i], 1);
} else {
b = Fraction(y[i], 1) - k * Fraction(x[i], 1);
}
k.reduce();
b.reduce();
st.insert(pair<Fraction, Fraction>(k, b));
}
}
for (auto p : st) {
mp[p.first]++;
}
long long res = cn2(st.size());
for (auto &p : mp) {
if (p.second >= 2) {
res -= cn2(p.second);
}
}
printf("%lld\n", res);
}
return 0;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
Kode Festival is an anual contest where the hardest stone in the world is determined. (Kode is a Japanese word for "hardness".)
This year, 2^N stones participated. The hardness of the i-th stone is A_i.
In the contest, stones are thrown at each other in a knockout tournament.
When two stones with hardness X and Y are thrown at each other, the following will happen:
* When X > Y: The stone with hardness Y will be destroyed and eliminated. The hardness of the stone with hardness X will become X-Y.
* When X = Y: One of the stones will be destroyed and eliminated. The hardness of the other stone will remain the same.
* When X < Y: The stone with hardness X will be destroyed and eliminated. The hardness of the stone with hardness Y will become Y-X.
The 2^N stones will fight in a knockout tournament as follows:
1. The following pairs will fight: (the 1-st stone versus the 2-nd stone), (the 3-rd stone versus the 4-th stone), ...
2. The following pairs will fight: (the winner of (1-st versus 2-nd) versus the winner of (3-rd versus 4-th)), (the winner of (5-th versus 6-th) versus the winner of (7-th versus 8-th)), ...
3. And so forth, until there is only one stone remaining.
Determine the eventual hardness of the last stone remaining.
Constraints
* 1 \leq N \leq 18
* 1 \leq A_i \leq 10^9
* A_i is an integer.
Input
The input is given from Standard Input in the following format:
N
A_1
A_2
:
A_{2^N}
Output
Print the eventual hardness of the last stone remaining.
Examples
Input
2
1
3
10
19
Output
7
Input
3
1
3
2
4
6
8
100
104
Output
2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
#define int long long // <-----!!!!!!!!!!!!!!!!!!!
#define rep(i,n) for (int i=0;i<(n);i++)
#define rep2(i,a,b) for (int i=(a);i<(b);i++)
#define rrep(i,n) for (int i=(n)-1;i>=0;i--)
#define rrep2(i,a,b) for (int i=(a)-1;i>=b;i--)
#define all(a) (a).begin(),(a).end()
#define rall(a) (a).rbegin(),(a).rend()
#define printV(_v) for(auto _x:_v){cout<<_x<<" ";}cout<<endl
#define printVS(_vs) for(auto _x : _vs){cout << _x << endl;}
#define printVV(_vv) for(auto _v:_vv){for(auto _x:_v){cout<<_x<<" ";}cout<<endl;} cout << endl;
#define printP(_p) cout << _p.first << " " << _p.second << endl
#define printVP(_vp) for(auto _p : _vp) printP(_p);
typedef long long ll;
typedef pair<int, int> Pii;
typedef tuple<int, int, int> TUPLE;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<vvi> vvvi;
typedef vector<Pii> vp;
const int inf = 1e9;
const int mod = 1e9 + 7;
typedef vector<vector<int>> Graph;
signed main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
int n;
cin >> n;
vi a(1 << n);
rep(i, 1 << n) cin >> a[i];
while (a.size() > 1) {
vi b;
for (int i = 0; i < a.size(); i += 2) {
if (a[i] == a[i + 1]) {
b.emplace_back(a[i]);
} else {
b.emplace_back(abs(a[i] - a[i + 1]));
}
}
a = b;
}
cout << a[0] << endl;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
Alice guesses the strings that Bob made for her.
At first, Bob came up with the secret string a consisting of lowercase English letters. The string a has a length of 2 or more characters. Then, from string a he builds a new string b and offers Alice the string b so that she can guess the string a.
Bob builds b from a as follows: he writes all the substrings of length 2 of the string a in the order from left to right, and then joins them in the same order into the string b.
For example, if Bob came up with the string a="abac", then all the substrings of length 2 of the string a are: "ab", "ba", "ac". Therefore, the string b="abbaac".
You are given the string b. Help Alice to guess the string a that Bob came up with. It is guaranteed that b was built according to the algorithm given above. It can be proved that the answer to the problem is unique.
Input
The first line contains a single positive integer t (1 ≤ t ≤ 1000) — the number of test cases in the test. Then t test cases follow.
Each test case consists of one line in which the string b is written, consisting of lowercase English letters (2 ≤ |b| ≤ 100) — the string Bob came up with, where |b| is the length of the string b. It is guaranteed that b was built according to the algorithm given above.
Output
Output t answers to test cases. Each answer is the secret string a, consisting of lowercase English letters, that Bob came up with.
Example
Input
4
abbaac
ac
bccddaaf
zzzzzzzzzz
Output
abac
ac
bcdaf
zzzzzz
Note
The first test case is explained in the statement.
In the second test case, Bob came up with the string a="ac", the string a has a length 2, so the string b is equal to the string a.
In the third test case, Bob came up with the string a="bcdaf", substrings of length 2 of string a are: "bc", "cd", "da", "af", so the string b="bccddaaf".
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
string b;
cin >> b;
string a = b.substr(0, 2);
for (int i = 2; i < b.length(); i += 2) {
string s = b.substr(i, 2);
a += s[1];
}
cout << a << endl;
}
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
A dragon symbolizes wisdom, power and wealth. On Lunar New Year's Day, people model a dragon with bamboo strips and clothes, raise them with rods, and hold the rods high and low to resemble a flying dragon.
A performer holding the rod low is represented by a 1, while one holding it high is represented by a 2. Thus, the line of performers can be represented by a sequence a1, a2, ..., an.
Little Tommy is among them. He would like to choose an interval [l, r] (1 ≤ l ≤ r ≤ n), then reverse al, al + 1, ..., ar so that the length of the longest non-decreasing subsequence of the new sequence is maximum.
A non-decreasing subsequence is a sequence of indices p1, p2, ..., pk, such that p1 < p2 < ... < pk and ap1 ≤ ap2 ≤ ... ≤ apk. The length of the subsequence is k.
Input
The first line contains an integer n (1 ≤ n ≤ 2000), denoting the length of the original sequence.
The second line contains n space-separated integers, describing the original sequence a1, a2, ..., an (1 ≤ ai ≤ 2, i = 1, 2, ..., n).
Output
Print a single integer, which means the maximum possible length of the longest non-decreasing subsequence of the new sequence.
Examples
Input
4
1 2 1 2
Output
4
Input
10
1 1 2 2 2 1 1 2 2 1
Output
9
Note
In the first example, after reversing [2, 3], the array will become [1, 1, 2, 2], where the length of the longest non-decreasing subsequence is 4.
In the second example, after reversing [3, 7], the array will become [1, 1, 1, 1, 2, 2, 2, 2, 2, 1], where the length of the longest non-decreasing subsequence is 9.
### Response
```cpp
#include <bits/stdc++.h>
int n;
int a[2005];
int ones[2005];
int twos[2005];
int dp[2005][2005][2];
int LMSL[2005][2005];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
ones[0] = 0;
for (int i = 1; i <= n; ++i) ones[i] = ones[i - 1] + (a[i] == 1);
twos[n + 1] = 0;
for (int i = n; i >= 1; --i) twos[i] = twos[i + 1] + (a[i] == 2);
for (int l = 1; l <= n; ++l) {
dp[l][l][1] = (a[l] == 2);
dp[l][l][0] = (a[l] == 1);
for (int r = l + 1; r <= n; ++r) {
dp[l][r][1] = dp[l][r - 1][1] + (a[r] == 2);
dp[l][r][0] = std::max(dp[l][r - 1][0], dp[l][r - 1][1]) + (a[r] == 1);
}
}
int ans = 0;
for (int l = 1; l <= n; ++l) {
for (int r = l; r <= n; ++r) {
LMSL[l][r] = std::max(dp[l][r][0], dp[l][r][1]);
ans = std::max(ans, LMSL[l][r] + ones[l - 1] + twos[r + 1]);
}
}
printf("%d\n", ans);
return 0;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
Arkady the air traffic controller is now working with n planes in the air. All planes move along a straight coordinate axis with Arkady's station being at point 0 on it. The i-th plane, small enough to be represented by a point, currently has a coordinate of xi and is moving with speed vi. It's guaranteed that xi·vi < 0, i.e., all planes are moving towards the station.
Occasionally, the planes are affected by winds. With a wind of speed vwind (not necessarily positive or integral), the speed of the i-th plane becomes vi + vwind.
According to weather report, the current wind has a steady speed falling inside the range [ - w, w] (inclusive), but the exact value cannot be measured accurately since this value is rather small — smaller than the absolute value of speed of any plane.
Each plane should contact Arkady at the exact moment it passes above his station. And you are to help Arkady count the number of pairs of planes (i, j) (i < j) there are such that there is a possible value of wind speed, under which planes i and j contact Arkady at the same moment. This value needn't be the same across different pairs.
The wind speed is the same for all planes. You may assume that the wind has a steady speed and lasts arbitrarily long.
Input
The first line contains two integers n and w (1 ≤ n ≤ 100 000, 0 ≤ w < 105) — the number of planes and the maximum wind speed.
The i-th of the next n lines contains two integers xi and vi (1 ≤ |xi| ≤ 105, w + 1 ≤ |vi| ≤ 105, xi·vi < 0) — the initial position and speed of the i-th plane.
Planes are pairwise distinct, that is, no pair of (i, j) (i < j) exists such that both xi = xj and vi = vj.
Output
Output a single integer — the number of unordered pairs of planes that can contact Arkady at the same moment.
Examples
Input
5 1
-3 2
-3 3
-1 2
1 -3
3 -5
Output
3
Input
6 1
-3 2
-2 2
-1 2
1 -2
2 -2
3 -2
Output
9
Note
In the first example, the following 3 pairs of planes satisfy the requirements:
* (2, 5) passes the station at time 3 / 4 with vwind = 1;
* (3, 4) passes the station at time 2 / 5 with vwind = 1 / 2;
* (3, 5) passes the station at time 4 / 7 with vwind = - 1 / 4.
In the second example, each of the 3 planes with negative coordinates can form a valid pair with each of the other 3, totaling 9 pairs.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long int w;
struct data {
long long int x, v;
} a[100005];
bool operator<(const data &a, const data &b) {
long long int t = (a.x * (b.v + w) - b.x * (a.v + w));
if (t > 0)
t = 1;
else if (t == 0)
t = 0;
else
t = -1;
t *= (a.v + w) * (b.v + w);
if (t != 0) return t < 0;
t = (a.x * (b.v - w) - b.x * (a.v - w));
if (t > 0)
t = 1;
else if (t == 0)
t = 0;
else
t = -1;
t *= (a.v - w) * (b.v - w);
return t > 0;
}
long double b[100005];
int fen[100005];
int n;
void update(int p, int val) {
for (int i = p; i <= n; i += i & -i) {
fen[i] += val;
}
}
int sum(int p) {
int ans = 0;
for (int i = p; i; i -= i & -i) {
ans += fen[i];
}
return ans;
}
vector<pair<long double, long long int> > v;
long long int c[100005];
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
cin >> n >> w;
for (int i = 1; i <= n; i++) cin >> a[i].x >> a[i].v;
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) b[i] = a[i].x * 1.0 / (a[i].v - w);
for (int i = 1; i <= n; i++)
v.push_back(pair<long double, long long int>(b[i], -i));
sort(v.begin(), v.end());
for (int i = 0; i < v.size(); i++) c[-v[i].second] = i + 1;
long long int res = 0;
for (int i = n; i >= 1; i--) {
res += sum(c[i]);
update(c[i], 1);
}
cout << res << endl;
return 0;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
Once Bob got to a sale of old TV sets. There were n TV sets at that sale. TV set with index i costs ai bellars. Some TV sets have a negative price — their owners are ready to pay Bob if he buys their useless apparatus. Bob can «buy» any TV sets he wants. Though he's very strong, Bob can carry at most m TV sets, and he has no desire to go to the sale for the second time. Please, help Bob find out the maximum sum of money that he can earn.
Input
The first line contains two space-separated integers n and m (1 ≤ m ≤ n ≤ 100) — amount of TV sets at the sale, and amount of TV sets that Bob can carry. The following line contains n space-separated integers ai ( - 1000 ≤ ai ≤ 1000) — prices of the TV sets.
Output
Output the only number — the maximum sum of money that Bob can earn, given that he can carry at most m TV sets.
Examples
Input
5 3
-6 0 35 -2 4
Output
8
Input
4 2
7 0 0 -7
Output
7
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int a[1004];
int size;
int n, m;
int main(void) {
while (scanf("%d %d", &n, &m) != EOF) {
size = 0;
int i;
for (i = 0; i < n; i++) {
int p;
scanf("%d", &p);
if (p < 0) a[size++] = p;
}
sort(a, a + size);
int sum = 0;
for (i = 0; i < m && i < size; i++) {
sum += a[i];
}
printf("%d\n", -sum);
}
return 0;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
Billy investigates the question of applying greedy algorithm to different spheres of life. At the moment he is studying the application of greedy algorithm to the problem about change. There is an amount of n coins of different face values, and the coins of each value are not limited in number. The task is to collect the sum x with the minimum amount of coins. Greedy algorithm with each its step takes the coin of the highest face value, not exceeding x. Obviously, if among the coins' face values exists the face value 1, any sum x can be collected with the help of greedy algorithm. However, greedy algorithm does not always give the optimal representation of the sum, i.e. the representation with the minimum amount of coins. For example, if there are face values {1, 3, 4} and it is asked to collect the sum 6, greedy algorithm will represent the sum as 4 + 1 + 1, while the optimal representation is 3 + 3, containing one coin less. By the given set of face values find out if there exist such a sum x that greedy algorithm will collect in a non-optimal way. If such a sum exists, find out the smallest of these sums.
Input
The first line contains an integer n (1 ≤ n ≤ 400) — the amount of the coins' face values. The second line contains n integers ai (1 ≤ ai ≤ 109), describing the face values. It is guaranteed that a1 > a2 > ... > an and an = 1.
Output
If greedy algorithm collects any sum in an optimal way, output -1. Otherwise output the smallest sum that greedy algorithm collects in a non-optimal way.
Examples
Input
5
25 10 5 2 1
Output
-1
Input
3
4 3 1
Output
6
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
static int N;
static int C[400];
long long value(int V[]) {
long long res = 0;
for (int n = 0; n < int(N); ++n) res += (long long)V[n] * C[n];
return res;
}
int size(int V[]) {
int res = 0;
for (int n = 0; n < int(N); ++n) res += V[n];
return res;
}
void greedy(int V[], long long tot) {
for (int n = 0; n < int(N); ++n) {
V[n] = tot / C[n];
tot %= C[n];
}
}
int main() {
int M[400], G[400];
long long tot, res = -1;
cin >> N;
for (int n = 0; n < int(N); ++n) cin >> C[n];
for (int i = 1; i < int(N); ++i) {
greedy(M, C[i - 1] - 1);
for (int j = N - 1; j >= int(i); --j) {
++M[j];
tot = value(M);
greedy(G, tot);
if (size(M) < size(G) && (res == -1 || tot < res)) res = tot;
M[j] = 0;
}
}
cout << res << endl;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
Mark and his crew are sailing across the sea of Aeolus (in Greek mythology Aeolus was the keeper of the winds). They have the map which represents the NxM matrix with land and sea fields and they want to get to the port (the port is considered as sea field). They are in a hurry because the wind there is very strong and changeable and they have the food for only K days on the sea (that is the maximum that they can carry on the ship). John, the guy from Mark's crew, knows how to predict the direction of the wind on daily basis for W days which is enough time for them to reach the port or to run out of the food. Mark can move the ship in four directions (north, east, south, west) by one field for one day, but he can also stay in the same place. Wind can blow in four directions (north, east, south, west) or just not blow that day. The wind is so strong at the sea of Aeolus that it moves the ship for one whole field in the direction which it blows at. The ship's resulting movement is the sum of the ship's action and wind from that day. Mark must be careful in order to keep the ship on the sea, the resulting movement must end on the sea field and there must be a 4-connected path through the sea from the starting field. A 4-connected path is a path where you can go from one cell to another only if they share a side.
For example in the following image, the ship can't move to the port as there is no 4-connected path through the sea.
<image>
In the next image, the ship can move to the port as there is a 4-connected path through the sea as shown with the red arrow. Furthermore, the ship can move to the port in one move if one of the following happens. Wind is blowing east and Mark moves the ship north, or wind is blowing north and Mark moves the ship east. In either of these scenarios the ship will end up in the port in one move.
<image>
Mark must also keep the ship on the map because he doesn't know what is outside. Lucky for Mark and his crew, there are T fish shops at the sea where they can replenish their food supplies to the maximum, but each shop is working on only one day. That means that Mark and his crew must be at the shop's position on the exact working day in order to replenish their food supplies. Help Mark to find the minimum of days that he and his crew need to reach the port or print -1 if that is impossible with the food supplies that they have.
Input
First line contains two integer numbers N and M (1 ≤ N, M ≤ 200) - representing the number of rows and number of columns of the map.
Second line contains three integers, K (0 ≤ K ≤ 200) which is the number of days with the available food supplies, T (0 ≤ T ≤ 20) which is the number of fields with additional food supplies and W (0 ≤ W ≤ 10^6) which is the number of days with wind information.
Next is the NxM char matrix filled with the values of 'L', 'S', 'P' or 'M'. 'L' is for the land and 'S' is for the sea parts. 'P' is for the port field and 'M' is the starting field for the ship.
Next line contains W chars with the wind direction information for every day. The possible inputs are 'N' - north, 'S' - south, 'E' - east, 'W' - west and 'C' - no wind. If Mark's crew can reach the port, it is guaranteed that they will not need more than W days to reach it.
In the end there are T lines with the food supplies positions. Each line contains three integers, Y_i and X_i (0 ≤ Y_i < N, 0 ≤ X_i < M) representing the coordinates (Y is row number and X is column number) of the food supply and F_i (0 ≤ F_i ≤ 10^6) representing the number of days from the starting day on which the food supply is available.
Output
One integer number representing the minimal days to reach the port or -1 if that is impossible.
Examples
Input
3 3
5 2 15
M S S
S S S
S S P
S W N N N N N N N N N N N N N
2 1 0
1 2 0
Output
-1
Input
3 3
5 2 15
M S S
S S S
S S P
S E N N N N N N N N N N N N N
2 1 0
1 2 0
Output
2
Input
5 5
4 1 15
M S S S S
S S S S L
S S S L L
S S S S S
S S S S P
C C C C S S E E C C C C C C C
0 1 4
Output
8
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return x * f;
}
const int N = 2e2 + 10, M = 2e6 + 10, dx[] = {-1, 1, 0, 0, 0},
dy[] = {0, 0, -1, 1, 0};
int n, m, k, t, w, W[M], f[M], sx, sy;
char mat[N][N];
bool vis[25][N][N][N];
vector<int> vec[N][N];
struct Node {
int x, y, last, k;
};
map<char, int> mp = {{'N', 0}, {'S', 1}, {'W', 2}, {'E', 3}, {'C', 4}};
inline bool check(int x, int y) {
if (x < 0 || y < 0 || x >= n || y >= m) return false;
if (mat[x][y] == 'L') return false;
return true;
}
inline void ha(Node x) { printf("ha:%d %d %d %d\n", x.x, x.y, x.last, x.k); }
inline int bfs() {
queue<Node> q;
q.push((Node){sx, sy, 0, k});
while (!q.empty()) {
Node u = q.front();
q.pop();
int x = u.x, y = u.y, last = u.last, cur = u.k, t = f[last] + k - cur;
if (mat[x][y] == 'P') return t;
if (mat[x][y] == 'L') continue;
if (vis[last][x][y][cur]) continue;
vis[last][x][y][cur] = true;
for (int i = 0; i < vec[x][y].size(); ++i)
if (t == f[vec[x][y][i]]) {
cur = k;
last = vec[x][y][i];
}
if (cur == 0) continue;
u = (Node){u.x + dx[W[t]], u.y + dy[W[t]], last, cur - 1};
if (check(u.x, u.y)) q.push(u);
for (int i = 0; i < 4; ++i) {
int tx = x + dx[i] + dx[W[t]], ty = y + dy[i] + dy[W[t]];
if ((check(x + dx[i], y + dy[i]) && check(tx, ty)) ||
(check(x + dx[W[t]], y + dy[W[t]]) && check(tx, ty))) {
u = (Node){tx, ty, last, cur - 1};
if (!vis[last][tx][ty][cur - 1]) q.push(u);
}
}
}
return -1;
}
int main() {
n = read();
m = read();
k = read();
t = read();
w = read();
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
cin >> mat[i][j];
if (mat[i][j] == 'M') {
sx = i;
sy = j;
}
}
for (int i = 0; i < w; ++i) {
char ch;
cin >> ch;
W[i] = mp[ch];
}
for (int i = 1; i <= t; ++i) {
int x = read(), y = read();
vec[x][y].push_back(i);
f[i] = read();
}
printf("%d\n", bfs());
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
The fundamental idea in the JPEG compression algorithm is to sort coeffi- cient of given image by zigzag path and encode it. In this problem, we don’t discuss about details of the algorithm, but you are asked to make simple pro- gram. You are given single integer N , and you must output zigzag path on a matrix where size is N by N . The zigzag scanning is start at the upper-left corner (0, 0) and end up at the bottom-right corner. See the following Figure and sample output to make sure rule of the zigzag scanning. For example, if you are given N = 8, corresponding output should be a matrix shown in right-side of the Figure. This matrix consists of visited time for each element.
<image>
Input
Several test cases are given. Each test case consists of one integer N (0 < N < 10) in a line. The input will end at a line contains single zero.
Output
For each input, you must output a matrix where each element is the visited time. All numbers in the matrix must be right justified in a field of width 3. Each matrix should be prefixed by a header “Case x:” where x equals test case number.
Example
Input
3
4
0
Output
Case 1:
1 2 6
3 5 7
4 8 9
Case 2:
1 2 6 7
3 5 8 13
4 9 12 14
10 11 15 16
### Response
```cpp
#include "bits/stdc++.h"
using namespace std;
//#define int long long
#define DBG 1
#define dump(o) if(DBG){cerr<<#o<<" "<<(o)<<endl;}
#define dumpc(o) if(DBG){cerr<<#o; for(auto &e:(o))cerr<<" "<<e;cerr<<endl;}
#define rep(i,a,b) for(int i=(a);i<(b);i++)
#define rrep(i,a,b) for(int i=(b)-1;i>=(a);i--)
#define all(c) begin(c),end(c)
const int INF = sizeof(int) == sizeof(long long) ? 0x3f3f3f3f3f3f3f3fLL : 0x3f3f3f3f;
const int MOD = (int)(1e9 + 7);
int n;
int dy[] = { -1,1 };
int dx[] = { 1,-1 };
int A[10][10];
bool isinrange(int y, int x) {
return 0 <= y&&y < n && 0 <= x&&x < n;
}
signed main() {
int c = 1;
while (cin >> n&&n) {
int y = 0, x = 0, idx = 1;
for (int i = 0; i < n * 2 - 1; i++) {
A[y][x] = idx++;
while (isinrange(y + dy[i % 2], x + dx[i % 2])) {
y += dy[i % 2];
x += dx[i % 2];
A[y][x] = idx++;
}
if (i < n - 1) {
if (i % 2 == 0)x++;
else y++;
}
else {
if (i % 2 == 1)x++;
else y++;
}
}
A[n - 1][n - 1] = n*n;
cout << "Case " << c++ << ":" << endl;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++)
printf("%3d", A[i][j]);
cout << endl;
}
}
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
Everybody knows that the m-coder Tournament will happen soon. m schools participate in the tournament, and only one student from each school participates.
There are a total of n students in those schools. Before the tournament, all students put their names and the names of their schools into the Technogoblet of Fire. After that, Technogoblet selects the strongest student from each school to participate.
Arkady is a hacker who wants to have k Chosen Ones selected by the Technogoblet. Unfortunately, not all of them are the strongest in their schools, but Arkady can make up some new school names and replace some names from Technogoblet with those. You can't use each made-up name more than once. In that case, Technogoblet would select the strongest student in those made-up schools too.
You know the power of each student and schools they study in. Calculate the minimal number of schools Arkady has to make up so that k Chosen Ones would be selected by the Technogoblet.
Input
The first line contains three integers n, m and k (1 ≤ n ≤ 100, 1 ≤ m, k ≤ n) — the total number of students, the number of schools and the number of the Chosen Ones.
The second line contains n different integers p_1, p_2, …, p_n (1 ≤ p_i ≤ n), where p_i denotes the power of i-th student. The bigger the power, the stronger the student.
The third line contains n integers s_1, s_2, …, s_n (1 ≤ s_i ≤ m), where s_i denotes the school the i-th student goes to. At least one student studies in each of the schools.
The fourth line contains k different integers c_1, c_2, …, c_k (1 ≤ c_i ≤ n) — the id's of the Chosen Ones.
Output
Output a single integer — the minimal number of schools to be made up by Arkady so that k Chosen Ones would be selected by the Technogoblet.
Examples
Input
7 3 1
1 5 3 4 6 7 2
1 3 1 2 1 2 3
3
Output
1
Input
8 4 4
1 2 3 4 5 6 7 8
4 3 2 1 4 3 2 1
3 4 5 6
Output
2
Note
In the first example there's just a single Chosen One with id 3. His power is equal to 3, but in the same school 1, there's a student with id 5 and power 6, and that means inaction would not lead to the latter being chosen. If we, however, make up a new school (let its id be 4) for the Chosen One, Technogoblet would select students with ids 2 (strongest in 3), 5 (strongest in 1), 6 (strongest in 2) and 3 (strongest in 4).
In the second example, you can change the school of student 3 to the made-up 5 and the school of student 4 to the made-up 6. It will cause the Technogoblet to choose students 8, 7, 6, 5, 3 and 4.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int a[105];
vector<pair<int, int>> g[105];
int mp[105];
int c[105];
int main() {
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
int id;
for (int i = 1; i <= n; i++) {
cin >> id;
mp[i] = id;
g[id].push_back(make_pair(a[i], i));
}
for (int i = 1; i <= k; i++) cin >> c[i];
for (int i = 1; i <= m; i++)
sort(g[i].begin(), g[i].end(), greater<pair<int, int>>());
int ans = 0;
for (int i = 1; i <= k; i++) {
if (a[c[i]] != g[mp[c[i]]][0].first) ans++;
}
cout << ans << endl;
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
Alice and Bob are playing a game. The game involves splitting up game pieces into two teams. There are n pieces, and the i-th piece has a strength pi.
The way to split up game pieces is split into several steps:
1. First, Alice will split the pieces into two different groups A and B. This can be seen as writing the assignment of teams of a piece in an n character string, where each character is A or B.
2. Bob will then choose an arbitrary prefix or suffix of the string, and flip each character in that suffix (i.e. change A to B and B to A). He can do this step at most once.
3. Alice will get all the pieces marked A and Bob will get all the pieces marked B.
The strength of a player is then the sum of strengths of the pieces in the group.
Given Alice's initial split into two teams, help Bob determine an optimal strategy. Return the maximum strength he can achieve.
Input
The first line contains integer n (1 ≤ n ≤ 5·105) — the number of game pieces.
The second line contains n integers pi (1 ≤ pi ≤ 109) — the strength of the i-th piece.
The third line contains n characters A or B — the assignment of teams after the first step (after Alice's step).
Output
Print the only integer a — the maximum strength Bob can achieve.
Examples
Input
5
1 2 3 4 5
ABABA
Output
11
Input
5
1 2 3 4 5
AAAAA
Output
15
Input
1
1
B
Output
1
Note
In the first sample Bob should flip the suffix of length one.
In the second sample Bob should flip the prefix or the suffix (here it is the same) of length 5.
In the third sample Bob should do nothing.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
map<string, int> mapik;
vector<string> vect;
int _tempik = 0;
int main() {
long long n;
cin >> n;
vector<long long> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
string s;
cin >> s;
vector<pair<long long, long long>> sum(n + 1);
vector<pair<long long, long long>> obr(n + 1);
sum[0] = make_pair(0, 0);
obr[0] = make_pair(0, 0);
for (int i = 0; i < n; i++) {
sum[i + 1] = sum[i];
obr[i + 1] = obr[i];
if (s[i] == 'A') {
sum[i + 1].first += a[i];
} else {
sum[i + 1].second += a[i];
}
if (s[n - 1 - i] == 'A') {
obr[i + 1].first += a[n - 1 - i];
} else {
obr[i + 1].second += a[n - 1 - i];
}
}
pair<long long, long long> res = sum[n];
long long ans = res.second;
for (int i = 1; i <= n; i++) {
pair<long long, long long> curres = res;
curres = make_pair(res.first - sum[i].first + sum[i].second,
res.second - sum[i].second + sum[i].first);
ans = max(curres.second, ans);
curres = res;
curres = make_pair(res.first - obr[i].first + obr[i].second,
res.second - obr[i].second + obr[i].first);
ans = max(curres.second, ans);
}
cout << ans;
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
Taro is addicted to a novel. The novel has n volumes in total, and each volume has a different thickness. Taro likes this novel so much that he wants to buy a bookshelf dedicated to it. However, if you put a large bookshelf in the room, it will be quite small, so you have to devise to make the width of the bookshelf as small as possible. When I measured the height from the floor to the ceiling, I found that an m-level bookshelf could be placed. So, how can we divide the n volumes of novels to minimize the width of the bookshelf in m columns? Taro is particular about it, and the novels to be stored in each column must be arranged in the order of the volume numbers. ..
Enter the number of bookshelves, the number of volumes of the novel, and the thickness of each book as input, and create a program to find the width of the bookshelf that has the smallest width that can accommodate all volumes in order from one volume. However, the size of the bookshelf frame is not included in the width.
<image>
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by two lines of zeros. Each dataset is given in the following format:
m n
w1
w2
::
wn
The first line gives m (1 ≤ m ≤ 20) the number of bookshelves that can be placed in the room and n (1 ≤ n ≤ 100) the number of volumes in the novel. The next n lines are given the integer wi (1 ≤ wi ≤ 1000000), which represents the thickness of the book in Volume i.
However, the width of the bookshelf shall not exceed 1500000.
The number of datasets does not exceed 50.
Output
Outputs the minimum bookshelf width for each dataset on one line.
Example
Input
3 9
500
300
800
200
100
600
900
700
400
4 3
1000
1000
1000
0 0
Output
1800
1000
### Response
```cpp
#include <iostream>
#include <algorithm>
#include <cmath>
using namespace std;
int n, m, max_a;
int a[100];
bool check(int k) {
int num = 1, sum = 0;
for(int i = 0; i < n; i++) {
sum += a[i];
if(sum > k) {
num++;
sum = a[i];
}
}
return num <= m;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
while(cin >> m >> n, m) {
for(int i = 0; i < n; i++) {
cin >> a[i];
}
max_a = *max_element(a, a + n);
int ng = max_a - 1, ok = max_a * n;
while(abs(ng - ok) > 1) {
int mid = (ng + ok) / 2;
if(check(mid)) ok = mid;
else ng = mid;
}
cout << ok << endl;
}
}
``` |
### Prompt
Generate a cpp solution to the following problem:
<image>
My grandmother uses a balance. The balance will balance if you place the same size on both of the two dishes, otherwise it will tilt to the heavier side. The weights of the 10 weights are 1g, 2g, 4g, 8g, 16g, 32g, 64g, 128g, 256g, 512g in order of lightness.
My grandmother says, "Weigh up to about 1 kg in grams." "Then, try to weigh the juice here," and my grandmother put the juice on the left plate and the 8g, 64g, and 128g weights on the right plate to balance. Then he answered, "The total weight is 200g, so the juice is 200g. How is it correct?"
Since the weight of the item to be placed on the left plate is given, create a program that outputs the weight to be placed on the right plate in order of lightness when balancing with the item of the weight given by the balance. However, the weight of the item to be weighed shall be less than or equal to the total weight of all weights (= 1023g).
Hint
The weight of the weight is 2 to the nth power (n = 0, 1, .... 9) g.
Input
Given multiple datasets. For each dataset, the weight of the item to be placed on the left plate is given in one line. Please process until the end of the input. The number of datasets does not exceed 50.
Output
For each data set, separate the weights (ascending order) to be placed on the right plate with one blank and output them on one line.
Example
Input
5
7
127
Output
1 4
1 2 4
1 2 4 8 16 32 64
### Response
```cpp
#include <iostream>
using namespace std;
int main()
{
int w;
while (cin >> w) {
int i = 0;
bool f = 0;
while ((1 << i) <= w) {
if ((1 << i) & w) {
if (f)
cout << " ";
else
f = 1;
cout << (1 << i);
}
i++;
}
cout << endl;
}
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
Andrewid the Android is a galaxy-known detective. Now he does not investigate any case and is eating chocolate out of boredom.
A bar of chocolate can be presented as an n × n table, where each cell represents one piece of chocolate. The columns of the table are numbered from 1 to n from left to right and the rows are numbered from top to bottom. Let's call the anti-diagonal to be a diagonal that goes the lower left corner to the upper right corner of the table. First Andrewid eats all the pieces lying below the anti-diagonal. Then he performs the following q actions with the remaining triangular part: first, he chooses a piece on the anti-diagonal and either direction 'up' or 'left', and then he begins to eat all the pieces starting from the selected cell, moving in the selected direction until he reaches the already eaten piece or chocolate bar edge.
After each action, he wants to know how many pieces he ate as a result of this action.
Input
The first line contains integers n (1 ≤ n ≤ 109) and q (1 ≤ q ≤ 2·105) — the size of the chocolate bar and the number of actions.
Next q lines contain the descriptions of the actions: the i-th of them contains numbers xi and yi (1 ≤ xi, yi ≤ n, xi + yi = n + 1) — the numbers of the column and row of the chosen cell and the character that represents the direction (L — left, U — up).
Output
Print q lines, the i-th of them should contain the number of eaten pieces as a result of the i-th action.
Examples
Input
6 5
3 4 U
6 1 L
2 5 L
1 6 U
4 3 U
Output
4
3
2
1
2
Input
10 6
2 9 U
10 1 U
1 10 U
8 3 L
10 1 L
6 5 U
Output
9
1
10
6
0
2
Note
Pictures to the sample tests:
<image>
The pieces that were eaten in the same action are painted the same color. The pieces lying on the anti-diagonal contain the numbers of the action as a result of which these pieces were eaten.
In the second sample test the Andrewid tries to start eating chocolate for the second time during his fifth action, starting from the cell at the intersection of the 10-th column and the 1-st row, but this cell is already empty, so he does not eat anything.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
set<pair<int, int> > s;
set<pair<int, int> >::iterator it;
int n, m;
int x[maxn];
int y[maxn];
char c[maxn];
int main() {
while (scanf("%d%d", &n, &m) != EOF) {
s.clear();
memset(x, 0, sizeof(x));
memset(y, 0, sizeof(y));
memset(c, 0, sizeof(c));
s.insert(make_pair(0, 0));
s.insert(make_pair(n + 1, m + 1));
for (int i = 1; i <= m; i++) {
scanf("%d %d %c", &x[i], &y[i], &c[i]);
if (c[i] == 'U') {
it = s.lower_bound(make_pair(x[i], -1));
if (it->first == x[i])
printf("0\n");
else {
s.insert(make_pair(x[i], i));
printf("%d\n", y[i] - y[it->second]);
y[i] = y[it->second];
}
} else {
it = s.upper_bound(make_pair(x[i], m + 1));
it--;
if (it->first == x[i])
printf("0\n");
else {
s.insert(make_pair(x[i], i));
printf("%d\n", x[i] - x[it->second]);
x[i] = x[it->second];
}
}
}
}
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
Let's define the permutation of length n as an array p = [p1, p2, ..., pn] consisting of n distinct integers from range from 1 to n. We say that this permutation maps value 1 into the value p1, value 2 into the value p2 and so on.
Kyota Ootori has just learned about cyclic representation of a permutation. A cycle is a sequence of numbers such that each element of this sequence is being mapped into the next element of this sequence (and the last element of the cycle is being mapped into the first element of the cycle). The cyclic representation is a representation of p as a collection of cycles forming p. For example, permutation p = [4, 1, 6, 2, 5, 3] has a cyclic representation that looks like (142)(36)(5) because 1 is replaced by 4, 4 is replaced by 2, 2 is replaced by 1, 3 and 6 are swapped, and 5 remains in place.
Permutation may have several cyclic representations, so Kyoya defines the standard cyclic representation of a permutation as follows. First, reorder the elements within each cycle so the largest element is first. Then, reorder all of the cycles so they are sorted by their first element. For our example above, the standard cyclic representation of [4, 1, 6, 2, 5, 3] is (421)(5)(63).
Now, Kyoya notices that if we drop the parenthesis in the standard cyclic representation, we get another permutation! For instance, [4, 1, 6, 2, 5, 3] will become [4, 2, 1, 5, 6, 3].
Kyoya notices that some permutations don't change after applying operation described above at all. He wrote all permutations of length n that do not change in a list in lexicographic order. Unfortunately, his friend Tamaki Suoh lost this list. Kyoya wishes to reproduce the list and he needs your help. Given the integers n and k, print the permutation that was k-th on Kyoya's list.
Input
The first line will contain two integers n, k (1 ≤ n ≤ 50, 1 ≤ k ≤ min{1018, l} where l is the length of the Kyoya's list).
Output
Print n space-separated integers, representing the permutation that is the answer for the question.
Examples
Input
4 3
Output
1 3 2 4
Input
10 1
Output
1 2 3 4 5 6 7 8 9 10
Note
The standard cycle representation is (1)(32)(4), which after removing parenthesis gives us the original permutation. The first permutation on the list would be [1, 2, 3, 4], while the second permutation would be [1, 2, 4, 3].
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long n, k, f[60];
void fib(int x) {
f[0] = 0, f[1] = 1;
for (int i = 2; i < x + 2; i++) f[i] = f[i - 1] + f[i - 2];
}
int main() {
cin >> n >> k;
fib(n);
for (int i = 0; i < n; i++) {
if (f[n - i] < k) {
k -= f[n - i];
cout << i + 2 << " " << i + 1 << " ";
i++;
} else
cout << i + 1 << " ";
;
}
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
Taro is playing with a puzzle that places numbers 1-9 in 9x9 squares. In this puzzle, you have to arrange the numbers according to the following rules.
* One number appears exactly once in the same column
* A number appears exactly once on the same line
* In each of the 3x3 ranges separated by double lines, a number appears exactly once.
For example, Figure 1 below is one arrangement that meets such a rule. However, Taro often creates an arrangement that violates the rules, as shown in Figure 2. The "2" appears twice in the leftmost column, the "1" never appears, the "1" appears twice in the second column from the left, and the "2" never appears. ..
<image> | <image>
--- | ---
Figure 1 | Figure 2
To help Taro, write a program that reads the arrangement of numbers, checks if the arrangement meets the rules, and outputs the location if it violates the rules. Please display * (half-width asterisk) before the number that is incorrect (appears more than once) according to the three rules, and blank before the number that is not incorrect.
Input
Given multiple datasets. The first row gives the number of datasets n (n ≤ 20). Each dataset is given a 9-character, 9-line numeric string that indicates the state of the puzzle.
Output
Output the following for each dataset.
Given number, * (half-width asterisk) and blank. Add * before the wrong number and a half-width space before the wrong number.
Insert a blank line between the datasets.
Example
Input
2
2 1 3 4 5 6 7 8 9
4 5 6 7 8 9 1 2 3
7 8 9 1 2 3 4 5 6
2 3 4 5 6 7 8 9 1
5 6 7 8 9 1 2 3 4
8 9 1 2 3 4 5 6 7
3 4 5 6 7 8 9 1 2
6 7 8 9 1 2 3 4 5
9 1 2 3 4 5 6 7 8
2 1 3 4 5 6 7 8 9
4 5 6 7 8 9 1 2 3
7 8 9 1 2 3 4 5 6
2 3 4 5 6 7 8 9 1
5 6 7 8 9 1 2 3 4
8 9 1 2 3 4 5 6 7
3 4 5 6 7 8 9 1 2
6 7 8 9 1 2 3 4 5
9 1 2 3 4 5 6 7 8
Output
*2*1 3 4 5 6 7 8 9
4 5 6 7 8 9 1 2 3
7 8 9 1 2 3 4 5 6
*2 3 4 5 6 7 8 9 1
5 6 7 8 9 1 2 3 4
8 9 1 2 3 4 5 6 7
3 4 5 6 7 8 9 1 2
6 7 8 9 1 2 3 4 5
9*1 2 3 4 5 6 7 8
*2*1 3 4 5 6 7 8 9
4 5 6 7 8 9 1 2 3
7 8 9 1 2 3 4 5 6
*2 3 4 5 6 7 8 9 1
5 6 7 8 9 1 2 3 4
8 9 1 2 3 4 5 6 7
3 4 5 6 7 8 9 1 2
6 7 8 9 1 2 3 4 5
9*1 2 3 4 5 6 7 8
### Response
```cpp
#include<cstdio>
using namespace std;
int main(){
int n,m[9][9];
char c[9][9];
scanf("%d",&n);
for(int i=0;i<n;i++){
for(int j=0;j<9;j++){
for(int k=0;k<9;k++){
scanf("%d",&m[j][k]);
c[j][k] = ' ';
}
}
int dx[9] = {0,1,2,0,1,2,0,1,2};
int dy[9] = {0,0,0,1,1,1,2,2,2};
for(int l=0;l<9;l++){
for(int j=0;j<8;j++){
for(int k = j+1;k<9;k++){
if(m[l][j] == m[l][k]){
c[l][j] = '*';
c[l][k] = '*';
}
if(m[j][l] == m[k][l]){
c[j][l] = '*';
c[k][l] = '*';
}
}
}
}
for(int j=0;j<=6;j+=3){
for(int k=0;k<=6;k+=3){
for(int l=0;l<8;l++){
for(int o=l+1;o<9;o++){
if(m[j+ dy[l]][k+ dx[l]] == m[j+ dy[o]][k+ dx[o]]){
c[j+ dy[l]][k+ dx[l]] = '*';
c[j+ dy[o]][k+ dx[o]] = '*';
}
}
}
}
}
for(int j=0;j<9;j++){
for(int k=0;k<9;k++){
printf("%c%d",c[j][k],m[j][k]);
}
putchar('\n');
}
if(i != n-1) putchar('\n');
}
return (0);
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
Alice and Bob are going to celebrate Christmas by playing a game with a tree of presents. The tree has n nodes (numbered 1 to n, with some node r as its root). There are a_i presents are hanging from the i-th node.
Before beginning the game, a special integer k is chosen. The game proceeds as follows:
* Alice begins the game, with moves alternating each turn;
* in any move, the current player may choose some node (for example, i) which has depth at least k. Then, the player picks some positive number of presents hanging from that node, let's call it m (1 ≤ m ≤ a_i);
* the player then places these m presents on the k-th ancestor (let's call it j) of the i-th node (the k-th ancestor of vertex i is a vertex j such that i is a descendant of j, and the difference between the depth of j and the depth of i is exactly k). Now, the number of presents of the i-th node (a_i) is decreased by m, and, correspondingly, a_j is increased by m;
* Alice and Bob both play optimally. The player unable to make a move loses the game.
For each possible root of the tree, find who among Alice or Bob wins the game.
Note: The depth of a node i in a tree with root r is defined as the number of edges on the simple path from node r to node i. The depth of root r itself is zero.
Input
The first line contains two space-separated integers n and k (3 ≤ n ≤ 10^5, 1 ≤ k ≤ 20).
The next n-1 lines each contain two integers x and y (1 ≤ x, y ≤ n, x ≠ y), denoting an undirected edge between the two nodes x and y. These edges form a tree of n nodes.
The next line contains n space-separated integers denoting the array a (0 ≤ a_i ≤ 10^9).
Output
Output n integers, where the i-th integer is 1 if Alice wins the game when the tree is rooted at node i, or 0 otherwise.
Example
Input
5 1
1 2
1 3
5 2
4 3
0 3 2 4 4
Output
1 0 0 1 1
Note
Let us calculate the answer for sample input with root node as 1 and as 2.
Root node 1
Alice always wins in this case. One possible gameplay between Alice and Bob is:
* Alice moves one present from node 4 to node 3.
* Bob moves four presents from node 5 to node 2.
* Alice moves four presents from node 2 to node 1.
* Bob moves three presents from node 2 to node 1.
* Alice moves three presents from node 3 to node 1.
* Bob moves three presents from node 4 to node 3.
* Alice moves three presents from node 3 to node 1.
Bob is now unable to make a move and hence loses.
Root node 2
Bob always wins in this case. One such gameplay is:
* Alice moves four presents from node 4 to node 3.
* Bob moves four presents from node 5 to node 2.
* Alice moves six presents from node 3 to node 1.
* Bob moves six presents from node 1 to node 2.
Alice is now unable to make a move and hence loses.
### Response
```cpp
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <vector>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <queue>
#include <ctime>
#include <cassert>
#include <complex>
#include <string>
#include <cstring>
#include <chrono>
#include <random>
#include <bitset>
using namespace std;
#ifdef LOCAL
#define eprintf(...) fprintf(stderr, __VA_ARGS__);fflush(stderr);
#else
#define eprintf(...) 42
#endif
using ll = long long;
using ld = long double;
using uint = unsigned int;
using ull = unsigned long long;
template<typename T>
using pair2 = pair<T, T>;
using pii = pair<int, int>;
using pli = pair<ll, int>;
using pll = pair<ll, ll>;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
ll myRand(ll B) {
return (ull)rng() % B;
}
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(),(x).end()
#define fi first
#define se second
clock_t startTime;
double getCurrentTime() {
return (double)(clock() - startTime) / CLOCKS_PER_SEC;
}
const int N = 100200;
const int K = 42;
int n, k;
vector<int> g[N];
int a[N];
int b[N][K];
int c[N][K];
int ans[N];
void dfs1(int v, int par) {
b[v][0] ^= a[v];
for (int u : g[v]) {
if (u == par) continue;
dfs1(u, v);
for (int i = 0; i < k; i++)
b[v][(i + 1) % k] ^= b[u][i];
}
}
void dfs2(int v, int par) {
for (int i = k / 2; i < k; i++)
ans[v] ^= b[v][i] ^ c[v][i];
for (int u : g[v]) {
if (u == par) continue;
for (int i = 0; i < k; i++) {
int x = b[v][i] ^ c[v][i];
x ^= b[u][(i + k - 1) % k];
c[u][(i + 1) % k] ^= x;
}
dfs2(u, v);
}
}
int main()
{
startTime = clock();
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
scanf("%d%d", &n, &k);
k *= 2;
for (int i = 1; i < n; i++) {
int v, u;
scanf("%d%d", &v, &u);
v--;u--;
g[v].push_back(u);
g[u].push_back(v);
}
for (int i = 0; i < n; i++)
scanf("%d", &a[i]);
dfs1(0, -1);
dfs2(0, -1);
for (int i = 0; i < n; i++)
printf("%d ", min(1, ans[i]));
printf("\n");
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
A little boy Petya dreams of growing up and becoming the Head Berland Plumber. He is thinking of the problems he will have to solve in the future. Unfortunately, Petya is too inexperienced, so you are about to solve one of such problems for Petya, the one he's the most interested in.
The Berland capital has n water tanks numbered from 1 to n. These tanks are connected by unidirectional pipes in some manner. Any pair of water tanks is connected by at most one pipe in each direction. Each pipe has a strictly positive integer width. Width determines the number of liters of water per a unit of time this pipe can transport. The water goes to the city from the main water tank (its number is 1). The water must go through some pipe path and get to the sewer tank with cleaning system (its number is n).
Petya wants to increase the width of some subset of pipes by at most k units in total so that the width of each pipe remains integer. Help him determine the maximum amount of water that can be transmitted per a unit of time from the main tank to the sewer tank after such operation is completed.
Input
The first line contains two space-separated integers n and k (2 ≤ n ≤ 50, 0 ≤ k ≤ 1000). Then follow n lines, each line contains n integers separated by single spaces. The i + 1-th row and j-th column contain number cij — the width of the pipe that goes from tank i to tank j (0 ≤ cij ≤ 106, cii = 0). If cij = 0, then there is no pipe from tank i to tank j.
Output
Print a single integer — the maximum amount of water that can be transmitted from the main tank to the sewer tank per a unit of time.
Examples
Input
5 7
0 1 0 2 0
0 0 4 10 0
0 0 0 0 5
0 0 0 0 10
0 0 0 0 0
Output
10
Input
5 10
0 1 0 0 0
0 0 2 0 0
0 0 0 3 0
0 0 0 0 4
100 0 0 0 0
Output
5
Note
In the first test Petya can increase width of the pipe that goes from the 1st to the 2nd water tank by 7 units.
In the second test Petya can increase width of the pipe that goes from the 1st to the 2nd water tank by 4 units, from the 2nd to the 3rd water tank by 3 units, from the 3rd to the 4th water tank by 2 units and from the 4th to 5th water tank by 1 unit.
### Response
```cpp
#include <bits/stdc++.h>
template <typename T>
inline void tension(T &a, const T &b) {
if (a > b) a = b;
}
template <typename T>
inline bool tensionv(T &a, const T &b) {
return a > b ? a = b, true : false;
}
inline unsigned int getuint() {
char w = getchar();
while (w < '0' || '9' < w) w = getchar();
unsigned int ans = 0;
for (; '0' <= w && w <= '9'; w = getchar()) ans = ans * 10 + w - '0';
return ans;
}
int V, S, T;
const int MAXV = 233333, MAXE = 233333;
struct Edge {
int t, next, cap, v;
} G[MAXE];
int head[MAXV], e = 1;
inline void add_double_edge(int x, int y, int z, int v) {
G[++e].t = y, G[e].next = head[x], head[x] = e;
G[e].cap = z, G[e].v = v;
G[++e].t = x, G[e].next = head[y], head[y] = e;
G[e].cap = 0, G[e].v = -v;
}
struct ZKW_Min_Cost_Flow {
int dist[MAXV], inq[MAXV];
std::pair<int, int> heap[MAXE];
int heap_size;
void SPFA() {
memset(dist + 1, 0x3f, sizeof(*dist) * V),
heap[heap_size++] = std::make_pair(-(dist[T] = 0), T),
std::push_heap(heap, heap + heap_size);
for (int d, x; heap_size;) {
d = -heap->first, x = heap->second,
std::pop_heap(heap, heap + heap_size--);
if (d != dist[x]) continue;
for (int i = head[x]; i; i = G[i].next)
if (G[i ^ 1].cap && tensionv(dist[G[i].t], dist[x] - G[i].v))
heap[heap_size++] = std::make_pair(-dist[G[i].t], G[i].t),
std::push_heap(heap, heap + heap_size);
}
}
int dfs(int x, int aug0) {
if (x == T) return aug0;
inq[x] = 1;
int aug = aug0;
for (int i = head[x]; i; i = G[i].next)
if (!inq[G[i].t] && G[i].cap && dist[x] == dist[G[i].t] + G[i].v) {
int flow = dfs(G[i].t, std::min(aug, G[i].cap));
if (flow) {
G[i].cap -= flow, G[i ^ 1].cap += flow, aug -= flow;
if (!aug) break;
}
}
return aug0 - aug;
}
bool modify_label() {
int t = 0x3f3f3f3f;
for (int x = 1; x <= V; x++)
if (inq[x])
for (int i = head[x]; i; i = G[i].next)
if (!inq[G[i].t] && G[i].cap)
tension(t, dist[G[i].t] + G[i].v - dist[x]);
if (t == 0x3f3f3f3f) return false;
for (int i = 1; i <= V; i++)
if (inq[i]) dist[i] += t;
return true;
}
int min_cost_flow(int limit) {
SPFA();
int ans = 0;
for (int now = limit; dist[S] <= now;) {
for (int t; dist[S] <= now;) {
memset(inq + 1, 0, sizeof(*inq) * V);
if (t = dfs(S, dist[S] ? now / dist[S] : 0x3f3f3f3f))
ans += t, now -= dist[S] * t;
else
break;
}
if (!modify_label()) break;
}
return ans;
}
} ZKW_MCF;
int main() {
int n = getuint(), m = getuint();
V = n, S = 1, T = n;
for (int x, i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (x = getuint())
add_double_edge(i, j, x, 0), add_double_edge(i, j, 0x3f3f3f3f, 1);
printf("%d\n", ZKW_MCF.min_cost_flow(m));
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
Vasya got really tired of these credits (from problem F) and now wants to earn the money himself! He decided to make a contest to gain a profit.
Vasya has n problems to choose from. They are numbered from 1 to n. The difficulty of the i-th problem is d_i. Moreover, the problems are given in the increasing order by their difficulties. The difficulties of all tasks are pairwise distinct. In order to add the i-th problem to the contest you need to pay c_i burles to its author. For each problem in the contest Vasya gets a burles.
In order to create a contest he needs to choose a consecutive subsegment of tasks.
So the total earnings for the contest are calculated as follows:
* if Vasya takes problem i to the contest, he needs to pay c_i to its author;
* for each problem in the contest Vasya gets a burles;
* let gap(l, r) = max_{l ≤ i < r} (d_{i + 1} - d_i)^2. If Vasya takes all the tasks with indices from l to r to the contest, he also needs to pay gap(l, r). If l = r then gap(l, r) = 0.
Calculate the maximum profit that Vasya can earn by taking a consecutive segment of tasks.
Input
The first line contains two integers n and a (1 ≤ n ≤ 3 ⋅ 10^5, 1 ≤ a ≤ 10^9) — the number of proposed tasks and the profit for a single problem, respectively.
Each of the next n lines contains two integers d_i and c_i (1 ≤ d_i, c_i ≤ 10^9, d_i < d_{i+1}).
Output
Print one integer — maximum amount of burles Vasya can earn.
Examples
Input
5 10
1 15
5 3
6 11
7 2
11 22
Output
13
Input
3 5
1 8
2 19
3 11
Output
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <class L, class R>
ostream &operator<<(ostream &os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")";
}
template <class T>
ostream &operator<<(ostream &os, vector<T> V) {
os << "[";
for (auto vv : V) os << vv << ",";
return os << "]";
}
template <class TH>
void _dbg(const char *sdbg, TH h) {
cerr << sdbg << '=' << h << '\n';
}
template <class TH, class... TA>
void _dbg(const char *sdbg, TH h, TA... a) {
while (*sdbg != ',') cerr << *sdbg++;
cerr << '=' << h << ',';
_dbg(sdbg + 1, a...);
}
const int N = 3e5 + 7;
const long long INF = 1e18 + 700;
int n, nge[N];
long long a, d[N], c[N], e[N];
long long t[4 * N], lazy[4 * N];
void push(int v) {
t[v * 2] += lazy[v];
lazy[v * 2] += lazy[v];
t[v * 2 + 1] += lazy[v];
lazy[v * 2 + 1] += lazy[v];
lazy[v] = 0;
}
void update(int v, int tl, int tr, int l, int r, long long addend) {
if (l > r) return;
if (l == tl && tr == r) {
t[v] += addend;
lazy[v] += addend;
} else {
push(v);
int tm = (tl + tr) / 2;
update(v * 2, tl, tm, l, min(r, tm), addend);
update(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r, addend);
t[v] = max(t[v * 2], t[v * 2 + 1]);
}
}
long long query(int v, int tl, int tr, int l, int r) {
if (l > r) return -INF;
if (l <= tl && tr <= r) return t[v];
push(v);
int tm = (tl + tr) / 2;
return max(query(v * 2, tl, tm, l, min(r, tm)),
query(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r));
}
void add(int l, int r, long long val) { update(1, 0, n, l, r, val); }
long long query(int l, int r) { return query(1, 0, n, l, r); }
void calc_nge() {
stack<int> st;
e[n] = 1e18 + 700;
for (int i = 1; i <= n; i++) {
while (!st.empty() && e[st.top()] <= e[i]) {
nge[st.top()] = i;
st.pop();
}
st.push(i);
}
assert(st.size() == 1);
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
cin >> n >> a;
for (int i = 1; i <= n; i++) cin >> d[i] >> c[i];
for (int i = 1; i <= n; i++) add(i, n, a - c[i]);
for (int i = 1; i <= n - 1; i++) e[i] = (d[i + 1] - d[i]) * (d[i + 1] - d[i]);
calc_nge();
int last = n;
long long ans = 0;
for (int i = 1; i <= n; i++) {
int cur = i;
if (i != n) {
while (cur != last) {
add(cur + 1, nge[cur], -e[cur]);
cur = nge[cur];
}
}
long long c_ans = query(i, n);
ans = max(ans, c_ans);
if (i < n) {
add(i + 1, n, c[i] - a);
add(i + 1, nge[i], e[i]);
last = nge[i];
}
}
cout << ans << '\n';
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
In problems on strings one often has to find a string with some particular properties. The problem authors were reluctant to waste time on thinking of a name for some string so they called it good. A string is good if it doesn't have palindrome substrings longer than or equal to d.
You are given string s, consisting only of lowercase English letters. Find a good string t with length |s|, consisting of lowercase English letters, which is lexicographically larger than s. Of all such strings string t must be lexicographically minimum.
We will call a non-empty string s[a ... b] = sasa + 1... sb (1 ≤ a ≤ b ≤ |s|) a substring of string s = s1s2... s|s|.
A non-empty string s = s1s2... sn is called a palindrome if for all i from 1 to n the following fulfills: si = sn - i + 1. In other words, palindrome read the same in both directions.
String x = x1x2... x|x| is lexicographically larger than string y = y1y2... y|y|, if either |x| > |y| and x1 = y1, x2 = y2, ... , x|y| = y|y|, or there exists such number r (r < |x|, r < |y|), that x1 = y1, x2 = y2, ... , xr = yr and xr + 1 > yr + 1. Characters in such strings are compared like their ASCII codes.
Input
The first line contains integer d (1 ≤ d ≤ |s|).
The second line contains a non-empty string s, its length is no more than 4·105 characters. The string consists of lowercase English letters.
Output
Print the good string that lexicographically follows s, has the same length and consists of only lowercase English letters. If such string does not exist, print "Impossible" (without the quotes).
Examples
Input
3
aaaaaaa
Output
aabbcaa
Input
3
zzyzzzz
Output
Impossible
Input
4
abbabbbabbb
Output
abbbcaaabab
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 400019, K = 26, mod = 1e9 + 7, base = 911;
string s;
int ls1[N], fen1[N], ls2[N], fen2[N];
int n, d, inv, po[N], poi[N];
void upd(int p, int val, int *f, int *l) {
val = (val + mod - l[p]) % mod;
l[p] += val;
l[p] %= mod;
for (p++; p < N; p += p & -p) f[p] += val, f[p] %= mod;
return;
}
int get(int p, int *f) {
int ret = 0;
for (; p > 0; p -= p & -p) ret = (ret + f[p]) % mod;
return ret;
}
int inc(int p) {
int flg = 0;
for (int i = p - 1; i >= 0; i--) {
if (s[i] != 'z') {
s[i]++;
long long vl1 = 1LL * s[i] * po[n - i - 1];
vl1 %= mod;
upd(i, vl1, fen1, ls1);
long long vl2 = 1LL * s[i] * po[i];
vl2 %= mod;
upd(i, vl2, fen2, ls2);
return i + 1;
break;
} else {
s[i] = 'a';
long long vl1 = 1LL * s[i] * po[n - i - 1];
vl1 %= mod;
upd(i, vl1, fen1, ls1);
long long vl2 = 1ll * s[i] * po[i];
vl2 %= mod;
upd(i, vl2, fen2, ls2);
}
}
if (!flg) {
cout << "Impossible\n";
exit(0);
}
return flg;
}
int le_ri(int l, int r) {
long long ret = get(r, fen1) + mod - get(l, fen1);
ret %= mod;
ret *= poi[n - r];
ret %= mod;
return ret;
}
int ri_le(int l, int r) {
long long ret = get(r, fen2) + mod - get(l, fen2);
ret %= mod;
ret *= poi[l];
ret %= mod;
return ret;
}
int power(int a, int b) {
if (b == 0) return 1;
long long ret = power(a, b / 2);
ret *= ret;
ret %= mod;
if (b & 1) ret *= a, ret %= mod;
return ret;
}
bool check(int len) {
if (len >= d)
if (le_ri(len - d, len) == ri_le(len - d, len)) return false;
if (len >= d + 1)
if (le_ri(len - d - 1, len) == ri_le(len - d - 1, len)) return false;
return true;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> d;
cin >> s;
n = s.size();
inv = power(base, mod - 2);
po[0] = poi[0] = 1;
for (int i = 1; i <= n; i++)
po[i] = (1LL * po[i - 1] * base) % mod,
poi[i] = (1LL * poi[i - 1] * inv) % mod;
for (int i = 0; i < n; i++) {
long long vl1 = 1LL * s[i] * po[n - i - 1];
vl1 %= mod;
upd(i, vl1, fen1, ls1);
long long vl2 = 1LL * s[i] * po[i];
vl2 %= mod;
upd(i, vl2, fen2, ls2);
}
inc(n);
int id = -1;
for (int i = 1; i <= n; i++) {
int len = i;
if (!check(i)) {
while (true) {
int c = inc(len);
bool flg = true;
int b = len;
for (int k = len; k >= c; k--)
if (!check(k)) flg = false, b = k;
len = b;
if (flg) break;
}
id = len;
break;
}
}
if (id == -1) return cout << s << endl, 0;
for (int i = id; i < n; i++) {
for (int k = 'a'; k < 'd'; k++) {
s[i] = k;
long long vl1 = 1LL * s[i] * po[n - i - 1];
vl1 %= mod;
upd(i, vl1, fen1, ls1);
long long vl2 = 1LL * s[i] * po[i];
vl2 %= mod;
upd(i, vl2, fen2, ls2);
if (check(i + 1)) break;
}
}
cout << s << endl;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
Little Petya loves looking for numbers' divisors. One day Petya came across the following problem:
You are given n queries in the form "xi yi". For each query Petya should count how many divisors of number xi divide none of the numbers xi - yi, xi - yi + 1, ..., xi - 1. Help him.
Input
The first line contains an integer n (1 ≤ n ≤ 105). Each of the following n lines contain two space-separated integers xi and yi (1 ≤ xi ≤ 105, 0 ≤ yi ≤ i - 1, where i is the query's ordinal number; the numeration starts with 1).
If yi = 0 for the query, then the answer to the query will be the number of divisors of the number xi. In this case you do not need to take the previous numbers x into consideration.
Output
For each query print the answer on a single line: the number of positive integers k such that <image>
Examples
Input
6
4 0
3 1
5 2
6 2
18 4
10000 3
Output
3
1
1
2
2
22
Note
Let's write out the divisors that give answers for the first 5 queries:
1) 1, 2, 4
2) 3
3) 5
4) 2, 6
5) 9, 18
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <class Ty, class Tx>
Ty cast(const Tx &x) {
Ty y;
stringstream ss("");
ss << x;
ss.seekg(0);
ss >> y;
return y;
}
int last[100005];
int main() {
int n, i, j, x, y, z;
for ((i) = 0; (i) < (100005); (i)++) last[i] = -1;
cin >> n;
for ((i) = 0; (i) < (n); (i)++) {
cin >> x >> y;
z = 0;
for (j = 1; j * j <= x; j++)
if (x % j == 0) {
if (last[j] < 0 || i - last[j] > y) z++;
last[j] = i;
if (j * j != x)
if (last[x / j] < 0 || i - last[x / j] > y) z++;
last[x / j] = i;
}
cout << z << endl;
}
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
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;
const int N = 1e5 + 10, INF = 0x3f3f3f3f;
char s[N];
struct node {
int pos, x;
} tree[N << 2];
vector<char> v;
int cnt[30];
void pushUp(int t) {
if (tree[t << 1].x < tree[t << 1 | 1].x) {
tree[t].x = tree[t << 1].x;
tree[t].pos = tree[t << 1].pos;
} else {
tree[t].x = tree[t << 1 | 1].x;
tree[t].pos = tree[t << 1 | 1].pos;
}
}
void update(int t, int L, int R, int x, int v) {
if (L == R && L == x) {
tree[t].x = v;
tree[t].pos = x;
return;
}
int mid = (L + R) >> 1;
if (x <= mid)
update(t << 1, L, mid, x, v);
else
update(t << 1 | 1, mid + 1, R, x, v);
pushUp(t);
}
int main() {
int m, i;
scanf("%d%s", &m, s);
memset(tree, 0x3f, sizeof tree);
int n = strlen(s), pos = -INF, mins = 26;
for (i = 0; i < min(m - 1, n); ++i) {
update(1, 1, n, i + 1, s[i] - 'a');
cnt[s[i] - 'a']++;
}
for (i = m - 1; i < n; ++i) {
cnt[s[i] - 'a']++;
update(1, 1, n, i + 1, s[i] - 'a');
if (i - m >= 0) update(1, 1, n, i - m + 1, INF);
if (pos >= i - m + 1 && pos <= i) continue;
pos = tree[1].pos - 1;
v.push_back(s[pos]);
}
sort(v.begin(), v.end());
i = 0;
char ans;
while (v[v.size() - 1] - 'a' > i) {
ans = 'a' + i;
for (int j = 0; j < cnt[i]; ++j) cout << ans;
++i;
}
for (i = 0; i < v.size() - 1; ++i)
if (v[i] == v[v.size() - 1]) break;
while (i < v.size()) {
cout << v[i];
++i;
}
printf("\n");
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
Fibonacci numbers are the sequence of integers: f0 = 0, f1 = 1, f2 = 1, f3 = 2, f4 = 3, f5 = 5, ..., fn = fn - 2 + fn - 1. So every next number is the sum of the previous two.
Bajtek has developed a nice way to compute Fibonacci numbers on a blackboard. First, he writes a 0. Then, below it, he writes a 1. Then he performs the following two operations:
* operation "T": replace the top number with the sum of both numbers;
* operation "B": replace the bottom number with the sum of both numbers.
If he performs n operations, starting with "T" and then choosing operations alternately (so that the sequence of operations looks like "TBTBTBTB..."), the last number written will be equal to fn + 1.
Unfortunately, Bajtek sometimes makes mistakes and repeats an operation two or more times in a row. For example, if Bajtek wanted to compute f7, then he would want to do n = 6 operations: "TBTBTB". If he instead performs the sequence of operations "TTTBBT", then he will have made 3 mistakes, and he will incorrectly compute that the seventh Fibonacci number is 10. The number of mistakes in the sequence of operations is the number of neighbouring equal operations («TT» or «BB»).
You are given the number n of operations that Bajtek has made in an attempt to compute fn + 1 and the number r that is the result of his computations (that is last written number). Find the minimum possible number of mistakes that Bajtek must have made and any possible sequence of n operations resulting in r with that number of mistakes.
Assume that Bajtek always correctly starts with operation "T".
Input
The first line contains the integers n and r (1 ≤ n, r ≤ 106).
Output
The first line of the output should contain one number — the minimum possible number of mistakes made by Bajtek. The second line should contain n characters, starting with "T", describing one possible sequence of operations with that number of mistakes. Each character must be either "T" or "B".
If the required sequence doesn't exist, output "IMPOSSIBLE" (without quotes).
Examples
Input
6 10
Output
2
TBBTTB
Input
4 5
Output
0
TBTB
Input
2 1
Output
IMPOSSIBLE
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 30;
int f(int x, int y, int n) {
int rr = 0;
for (; n >= 3; --n) {
if (y <= 0) return INF;
if (y >= x - y) {
int t = y;
y = x - t;
x = t;
} else {
x = x - y;
++rr;
}
}
if (x != 2 || y != 1) return INF;
return rr;
}
string g(int x, int y, int n) {
int nn = n;
vector<int> rr;
for (; n >= 3; --n) {
if (y >= x - y) {
int t = y;
y = x - t;
x = t;
} else {
x = x - y;
rr.push_back(n);
}
}
reverse(rr.begin(), rr.end());
rr.push_back(-1);
string s = "TB";
int p = 0;
for (int i = 3; i <= nn; ++i) {
if (rr[p] == i) {
++p;
s += s[s.length() - 1] == 'T' ? 'T' : 'B';
} else {
s += s[s.length() - 1] == 'T' ? 'B' : 'T';
}
}
return s;
}
int main() {
int n, r;
cin >> n >> r;
if (n <= 3) {
if (n == r) {
cout << 0 << endl;
cout << string("TBT").substr(0, n) << endl;
} else {
cout << "IMPOSSIBLE" << endl;
}
return 0;
}
if (r < n) {
cout << "IMPOSSIBLE" << endl;
return 0;
}
int ans = INF;
int ii = -1;
for (int i = 1; i < r; ++i) {
int rr = f(r, i, n);
if (rr < ans) {
ans = rr;
ii = i;
}
}
if (ans == INF) {
cout << "IMPOSSIBLE" << endl;
} else {
cout << ans << endl;
cout << g(r, ii, n) << endl;
}
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
Codeforces is a wonderful platform and one its feature shows how much someone contributes to the community. Every registered user has contribution — an integer number, not necessarily positive. There are n registered users and the i-th of them has contribution ti.
Limak is a little polar bear and he's new into competitive programming. He doesn't even have an account in Codeforces but he is able to upvote existing blogs and comments. We assume that every registered user has infinitely many blogs and comments.
* Limak can spend b minutes to read one blog and upvote it. Author's contribution will be increased by 5.
* Limak can spend c minutes to read one comment and upvote it. Author's contribution will be increased by 1.
Note that it's possible that Limak reads blogs faster than comments.
Limak likes ties. He thinks it would be awesome to see a tie between at least k registered users. To make it happen he is going to spend some time on reading and upvoting. After that, there should exist an integer value x that at least k registered users have contribution exactly x.
How much time does Limak need to achieve his goal?
Input
The first line contains four integers n, k, b and c (2 ≤ k ≤ n ≤ 200 000, 1 ≤ b, c ≤ 1000) — the number of registered users, the required minimum number of users with the same contribution, time needed to read and upvote a blog, and time needed to read and upvote a comment, respectively.
The second line contains n integers t1, t2, ..., tn (|ti| ≤ 109) where ti denotes contribution of the i-th registered user.
Output
Print the minimum number of minutes Limak will spend to get a tie between at least k registered users.
Examples
Input
4 3 100 30
12 2 6 1
Output
220
Input
4 3 30 100
12 2 6 1
Output
190
Input
6 2 987 789
-8 42 -4 -65 -8 -8
Output
0
Note
In the first sample, there are 4 registered users and Limak wants a tie between at least 3 of them. Limak should behave as follows.
* He spends 100 minutes to read one blog of the 4-th user and increase his contribution from 1 to 6.
* Then he spends 4·30 = 120 minutes to read four comments of the 2-nd user and increase his contribution from 2 to 6 (four times it was increaded by 1).
In the given scenario, Limak spends 100 + 4·30 = 220 minutes and after that each of users 2, 3, 4 has contribution 6.
In the second sample, Limak needs 30 minutes to read a blog and 100 minutes to read a comment. This time he can get 3 users with contribution equal to 12 by spending 100 + 3·30 = 190 minutes:
* Spend 2·30 = 60 minutes to read two blogs of the 1-st user to increase his contribution from 2 to 12.
* Spend 30 + 100 minutes to read one blog and one comment of the 3-rd user. His contribution will change from 6 to 6 + 5 + 1 = 12.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct sth {
long long v, c;
} m[5][200010], h[5][200010];
long long n, k, b, c, tmp, xl;
long long minh = 9223372036854775807, tc;
long long v[200010];
long long pre[200010];
long long ma[5], l[5], Cos[5];
bool cmp2(sth x, sth y) {
return x.c + (ma[xl] - x.v) / 5 * b < y.c + (ma[xl] - y.v) / 5 * b;
}
int main() {
scanf("%I64d%I64d%I64d%I64d", &n, &k, &b, &c);
for (int i = 1; i <= n; i++) scanf("%I64d", &v[i]);
sort(v + 1, v + 1 + n);
for (int i = 1; i <= n; i++) {
tmp = (v[i] % 5 + 5) % 5;
tc = 0;
m[tmp][i].v = v[i];
m[tmp][i].c = 0;
for (int j = 1; j <= 4; j++) {
tmp = (tmp + 1) % 5;
tc += c;
m[tmp][i].v = v[i] + j;
m[tmp][i].c = tc;
}
}
for (int i = 1; i <= n; i++) {
pre[i] = pre[i - 1] + v[i];
if (i >= k) {
tc = v[i] * k - (pre[i] - pre[i - k]);
minh = min(tc * c, minh);
}
}
for (int j = 0; j <= 4; j++) {
ma[j] = m[j][1].v;
for (int i = 1; i <= k; i++) {
Cos[j] += l[j] * ((m[j][i].v - ma[j]) / 5 * b) + m[j][i].c;
ma[j] = max(ma[j], m[j][i].v);
l[j]++;
h[j][l[j]] = m[j][i];
xl = j;
push_heap(h[j] + 1, h[j] + l[j] + 1, cmp2);
}
minh = min(minh, Cos[j]);
}
for (int j = 0; j <= 4; j++)
for (int i = k + 1; i <= n; i++) {
xl = j;
pop_heap(h[j] + 1, h[j] + l[j] + 1, cmp2);
Cos[j] -= (ma[j] - h[j][k].v) / 5 * b + h[j][k].c;
Cos[j] += (k - 1) * ((m[j][i].v - ma[j]) / 5 * b) + m[j][i].c;
ma[j] = max(ma[j], m[j][i].v);
h[j][k] = m[j][i];
push_heap(h[j] + 1, h[j] + k + 1, cmp2);
minh = min(minh, Cos[j]);
}
printf("%I64d", minh);
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
A tourist wants to visit country Zeydabad for Zbazi (a local game in Zeydabad).
The country Zeydabad is a rectangular table consisting of n rows and m columns. Each cell on the country is either 'z' or '.'.
The tourist knows this country is named Zeydabad because there are lots of ''Z-pattern"s in the country. A ''Z-pattern" is a square which anti-diagonal is completely filled with 'z' and its upper and lower rows are also completely filled with 'z'. All other cells of a square can be arbitrary.
<image>
Note that a ''Z-pattern" can consist of only one cell (see the examples).
So he wants to count the number of ''Z-pattern"s in the country (a necessary skill for Zbazi).
Now your task is to help tourist with counting number of ''Z-pattern"s.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use gets/scanf/printf instead of getline/cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 3000) — the number of rows and columns respectively.
Each of the next n lines contains m characters 'z' or '.' — the description of Zeydabad.
Output
Print the only integer a — the number of ''Z-pattern"s in Zeydabad.
Examples
Input
4 4
zzzz
zzz.
.z..
zzzz
Output
16
Input
1 4
z.z.
Output
2
Input
2 2
zz
zz
Output
5
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m, tl[3010][3010], tz[3010][3010], tr[3010][3010], z[3010][3010],
t[3010];
long long r, bit[3010];
vector<int> del[3010];
char c;
long long getsum(int index) {
long long sum = 0;
while (index) {
sum += bit[index];
index -= index & (-index);
}
return sum;
}
void update(int index, long long val) {
while (index <= n) {
bit[index] += val;
index += index & (-index);
}
return;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
scanf(" %c", &c);
if (c == 'z') tl[i][j] = 1 + tl[i][j - 1];
}
}
for (int i = 1; i <= n; i++) {
for (int j = m; j > 0; j--) {
if (tl[i][j]) {
tr[i][j] = 1 + tr[i][j + 1];
tz[i][j] = 1 + tz[i - 1][j + 1];
}
}
}
for (int i = 1; i <= m; i++) {
for (int j = 0; j <= i; j++) {
del[j].clear();
t[j] = 0;
bit[j] = 0;
}
for (int j = 1; i - j >= 0 && j <= n; j++) {
update(j, 1);
del[j + tl[j][i - j + 1]].push_back(j);
t[j + tl[j][i - j + 1]]++;
for (int k = 0; k < t[j]; k++) update(del[j][k], -1);
r += getsum(j);
r -= getsum(j - min(tr[j][i - j + 1], tz[j][i - j + 1]));
}
}
for (int i = 2; i <= n; i++) {
for (int j = 0; j <= m; j++) {
del[j].clear();
t[j] = 0;
bit[j] = 0;
}
for (int j = 1; i + j - 1 <= n && j <= m; j++) {
update(j, 1);
del[j + tl[i + j - 1][m - j + 1]].push_back(j);
t[j + tl[i + j - 1][m - j + 1]]++;
for (int k = 0; k < t[j]; k++) update(del[j][k], -1);
r += getsum(j);
r -= getsum(j - min(tr[i + j - 1][m - j + 1], tz[i + j - 1][m - j + 1]));
}
}
printf("%lld\n", r);
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
Smart Beaver recently got interested in a new word game. The point is as follows: count the number of distinct good substrings of some string s. To determine if a string is good or not the game uses rules. Overall there are n rules. Each rule is described by a group of three (p, l, r), where p is a string and l and r (l ≤ r) are integers. We’ll say that string t complies with rule (p, l, r), if the number of occurrences of string t in string p lies between l and r, inclusive. For example, string "ab", complies with rules ("ab", 1, 2) and ("aab", 0, 1), but does not comply with rules ("cd", 1, 2) and ("abab", 0, 1).
A substring s[l... r] (1 ≤ l ≤ r ≤ |s|) of string s = s1s2... s|s| (|s| is a length of s) is string slsl + 1... sr.
Consider a number of occurrences of string t in string p as a number of pairs of integers l, r (1 ≤ l ≤ r ≤ |p|) such that p[l... r] = t.
We’ll say that string t is good if it complies with all n rules. Smart Beaver asks you to help him to write a program that can calculate the number of distinct good substrings of string s. Two substrings s[x... y] and s[z... w] are cosidered to be distinct iff s[x... y] ≠ s[z... w].
Input
The first line contains string s. The second line contains integer n. Next n lines contain the rules, one per line. Each of these lines contains a string and two integers pi, li, ri, separated by single spaces (0 ≤ li ≤ ri ≤ |pi|). It is guaranteed that all the given strings are non-empty and only contain lowercase English letters.
The input limits for scoring 30 points are (subproblem G1):
* 0 ≤ n ≤ 10.
* The length of string s and the maximum length of string p is ≤ 200.
The input limits for scoring 70 points are (subproblems G1+G2):
* 0 ≤ n ≤ 10.
* The length of string s and the maximum length of string p is ≤ 2000.
The input limits for scoring 100 points are (subproblems G1+G2+G3):
* 0 ≤ n ≤ 10.
* The length of string s and the maximum length of string p is ≤ 50000.
Output
Print a single integer — the number of good substrings of string s.
Examples
Input
aaab
2
aa 0 0
aab 1 1
Output
3
Input
ltntlnen
3
n 0 0
ttlneenl 1 4
lelllt 1 1
Output
2
Input
a
0
Output
1
Note
There are three good substrings in the first sample test: «aab», «ab» and «b».
In the second test only substrings «e» and «t» are good.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1200005;
int n;
int ch[N][26], prt[N], len[N], Right[N][11];
int rt, Lst, pool = 0;
int newnode(int l) {
int nx = ++pool;
len[nx] = l;
return nx;
}
char s[11][50050];
int L[20], R[20];
vector<int> T[N << 1];
void DFS(int u) {
for (auto v : T[u]) {
DFS(v);
for (int i = 0; i <= n; ++i) Right[u][i] += Right[v][i];
}
}
void ins(int w) {
int p = Lst, nx = newnode(len[p] + 1);
Lst = nx;
for (; p && !ch[p][w]; p = prt[p]) ch[p][w] = nx;
if (!p)
prt[nx] = rt;
else {
int q = ch[p][w];
if (len[q] == len[p] + 1)
prt[nx] = q;
else {
int newq = newnode(len[p] + 1);
for (int i = 0; i < 26; ++i) ch[newq][i] = ch[q][i];
prt[newq] = prt[q];
prt[q] = prt[nx] = newq;
for (; p && ch[p][w] == q; p = prt[p]) ch[p][w] = newq;
}
}
}
int main() {
scanf("%s%d", s[0], &n);
for (int i = 1; i <= n; ++i) scanf("%s%d%d", s[i], &L[i], &R[i]);
rt = Lst = newnode(0);
for (int i = 0; i <= n; ++i) {
Lst = rt;
int l = strlen(s[i]);
for (int j = 0; j < l; ++j) ins(s[i][j] - 'a'), Right[Lst][i]++;
}
for (int i = 2; i <= pool; ++i) T[prt[i]].push_back(i);
DFS(rt);
long long S = 0;
for (int u = 2; u <= pool; ++u)
if (Right[u][0]) {
bool flag = 1;
for (int i = 1; i <= n; ++i)
if (Right[u][i] < L[i] || R[i] < Right[u][i]) {
flag = 0;
break;
}
if (flag) S += len[u] - len[prt[u]];
}
cout << S << '\n';
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
Let us consider the following operations on a string consisting of `A` and `B`:
1. Select a character in a string. If it is `A`, replace it with `BB`. If it is `B`, replace with `AA`.
2. Select a substring that is equal to either `AAA` or `BBB`, and delete it from the string.
For example, if the first operation is performed on `ABA` and the first character is selected, the string becomes `BBBA`. If the second operation is performed on `BBBAAAA` and the fourth through sixth characters are selected, the string becomes `BBBA`.
These operations can be performed any number of times, in any order.
You are given two string S and T, and q queries a_i, b_i, c_i, d_i. For each query, determine whether S_{a_i} S_{{a_i}+1} ... S_{b_i}, a substring of S, can be made into T_{c_i} T_{{c_i}+1} ... T_{d_i}, a substring of T.
Constraints
* 1 \leq |S|, |T| \leq 10^5
* S and T consist of letters `A` and `B`.
* 1 \leq q \leq 10^5
* 1 \leq a_i \leq b_i \leq |S|
* 1 \leq c_i \leq d_i \leq |T|
Input
Input is given from Standard Input in the following format:
S
T
q
a_1 b_1 c_1 d_1
...
a_q b_q c_q d_q
Output
Print q lines. The i-th line should contain the response to the i-th query. If S_{a_i} S_{{a_i}+1} ... S_{b_i} can be made into T_{c_i} T_{{c_i}+1} ... T_{d_i}, print `YES`. Otherwise, print `NO`.
Examples
Input
BBBAAAABA
BBBBA
4
7 9 2 5
7 9 1 4
1 7 2 5
1 7 2 4
Output
YES
NO
YES
NO
Input
AAAAABBBBAAABBBBAAAA
BBBBAAABBBBBBAAAAABB
10
2 15 2 13
2 13 6 16
1 13 2 20
4 20 3 20
1 18 9 19
2 14 1 11
3 20 3 15
6 16 1 17
4 18 8 20
7 20 3 14
Output
YES
YES
YES
YES
YES
YES
NO
NO
NO
NO
### Response
```cpp
#include<stdio.h>
#include<vector>
#include<algorithm>
#include<string>
#include<iostream>
using namespace std;
int r1[101010], r2[101010];
int main()
{
string s, t;
cin >> s >> t;
for (int i = 0; i < s.size(); i++)r1[i + 1] = r1[i] + (s[i] - 'A' + 1);
for (int i = 0; i < t.size(); i++)r2[i + 1] = r2[i] + (t[i] - 'A' + 1);
int query;
scanf("%d", &query);
for (int i = 0; i < query; i++)
{
int za, zb, zc, zd;
scanf("%d%d%d%d", &za, &zb, &zc, &zd);
if ((r1[zb] - r1[za - 1]) % 3 == (r2[zd] - r2[zc - 1]) % 3)printf("YES\n");
else printf("NO\n");
}
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
Example
Input
acmicpc
tsukuba
Output
No
### Response
```cpp
#include <iostream>
#include <algorithm>
#include <iomanip>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <numeric>
#include <bitset>
#include <cmath>
static const int MOD = 1000000007;
using ll = long long;
using u32 = uint32_t;
using namespace std;
template<class T> constexpr T INF = ::numeric_limits<T>::max() / 32 * 15 + 208;
int main() {
string s, t;
cin >> s >> t;
string s1, s2;
for (int i = 0; i < s.size(); ++i) {
if(i&1) s1 += s[i];
else s2 += s[i];
}
s1 += '?', s2 += '?';
int cnt = 0;
for (char i : t) {
if(s1[cnt] == i) cnt++;
}
if(cnt+1 == s1.size()) {
puts("Yes");
return -0;
}
cnt = 0;
for (char i : t) {
if(s2[cnt] == i) cnt++;
}
if(cnt+1 == s2.size()) {
puts("Yes");
return -0;
}
puts("No");
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
There is a rectangle in a coordinate plane. The coordinates of the four vertices are (0,0), (W,0), (W,H), and (0,H). You are given a point (x,y) which is within the rectangle or on its border. We will draw a straight line passing through (x,y) to cut the rectangle into two parts. Find the maximum possible area of the part whose area is not larger than that of the other. Additionally, determine if there are multiple ways to cut the rectangle and achieve that maximum.
Constraints
* 1 \leq W,H \leq 10^9
* 0\leq x\leq W
* 0\leq y\leq H
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
W H x y
Output
Print the maximum possible area of the part whose area is not larger than that of the other, followed by `1` if there are multiple ways to cut the rectangle and achieve that maximum, and `0` otherwise.
The area printed will be judged correct when its absolute or relative error is at most 10^{-9}.
Examples
Input
2 3 1 2
Output
3.000000 0
Input
2 2 1 1
Output
2.000000 1
### Response
```cpp
#include<iostream>
using namespace std;
int main(){
int W, H, x, y;
cin >> W >> H >> x >> y;
int f = (x*2==W && y*2==H)?1:0;
cout << 0.5*W*H << " " << f << endl;
return 0;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
There is a grid of squares with H+1 horizontal rows and W vertical columns.
You will start at one of the squares in the top row and repeat moving one square right or down. However, for each integer i from 1 through H, you cannot move down from the A_i-th, (A_i + 1)-th, \ldots, B_i-th squares from the left in the i-th row from the top.
For each integer k from 1 through H, find the minimum number of moves needed to reach one of the squares in the (k+1)-th row from the top. (The starting square can be chosen individually for each case.) If, starting from any square in the top row, none of the squares in the (k+1)-th row can be reached, print `-1` instead.
Constraints
* 1 \leq H,W \leq 2\times 10^5
* 1 \leq A_i \leq B_i \leq W
Input
Input is given from Standard Input in the following format:
H W
A_1 B_1
A_2 B_2
:
A_H B_H
Output
Print H lines. The i-th line should contain the answer for the case k=i.
Example
Input
4 4
2 4
1 1
2 3
2 4
Output
1
3
6
-1
### Response
```cpp
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (int)(n); i ++)
#define irep(i,n) for (int i = (int)(n) - 1;i >= 0;--i)
using namespace std;
using ll = long long;
using PL = pair<ll,ll>;
using P = pair<int,int>;
constexpr int INF = 1000000000;
constexpr long long HINF = 1000000000000000;
constexpr long long MOD = 1000000007;// = 998244353;
constexpr double EPS = 1e-4;
constexpr double PI = 3.14159265358979;
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int H,W; cin >> H >> W;
map<int,int> mp;
multiset<int> st;
rep(i,W) mp[i] = i;
rep(i,W) st.insert(0);
rep(i,H) {
int l,r; cin >> l >> r;
--l;
auto itr = mp.lower_bound(l);
int rr = -1;
while (itr != mp.end() && itr->first <= r){
rr = max(rr,itr->second);
int v = (*itr).first - (*itr).second;
st.erase(st.find(v));
mp.erase(itr++);
}
if (rr != -1 && r < W) {
mp[r] = rr;
st.insert(r - rr);
}
int ans = -1;
if ((int)st.size() > 0) {
ans = *st.begin() + i + 1;
}
cout << ans << '\n';
}
return 0;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
There are n piles of pebbles on the table, the i-th pile contains ai pebbles. Your task is to paint each pebble using one of the k given colors so that for each color c and any two piles i and j the difference between the number of pebbles of color c in pile i and number of pebbles of color c in pile j is at most one.
In other words, let's say that bi, c is the number of pebbles of color c in the i-th pile. Then for any 1 ≤ c ≤ k, 1 ≤ i, j ≤ n the following condition must be satisfied |bi, c - bj, c| ≤ 1. It isn't necessary to use all k colors: if color c hasn't been used in pile i, then bi, c is considered to be zero.
Input
The first line of the input contains positive integers n and k (1 ≤ n, k ≤ 100), separated by a space — the number of piles and the number of colors respectively.
The second line contains n positive integers a1, a2, ..., an (1 ≤ ai ≤ 100) denoting number of pebbles in each of the piles.
Output
If there is no way to paint the pebbles satisfying the given condition, output "NO" (without quotes) .
Otherwise in the first line output "YES" (without quotes). Then n lines should follow, the i-th of them should contain ai space-separated integers. j-th (1 ≤ j ≤ ai) of these integers should be equal to the color of the j-th pebble in the i-th pile. If there are several possible answers, you may output any of them.
Examples
Input
4 4
1 2 3 4
Output
YES
1
1 4
1 2 4
1 2 3 4
Input
5 2
3 2 4 1 3
Output
NO
Input
5 4
3 2 4 3 5
Output
YES
1 2 3
1 3
1 2 3 4
1 3 4
1 1 2 3 4
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void HoH() {
ios::sync_with_stdio(0), ios_base::sync_with_stdio(0), cin.tie(0),
cout.tie(0);
}
int main() {
HoH();
int n, k;
cin >> n >> k;
int m = INT_MIN, s = INT_MAX;
int x;
int a[n];
for (int i = 0; i < n; ++i) {
cin >> a[i];
m = max(m, a[i]), s = min(s, a[i]);
}
if (k + s >= m) {
cout << "YES" << endl;
for (int i = 0; i < n; ++i) {
for (int j = 1; j <= s; j++) {
if (j % k == 0) {
cout << k << " ";
} else if (j % k != 0) {
cout << (j % (k)) << " ";
} else
cout << j << " ";
}
for (int j = 1; j <= a[i] - s; j++) {
if (j % k == 0) {
cout << k << " ";
} else if (j % k != 0) {
cout << (j % (k)) << " ";
} else
cout << j << " ";
}
cout << endl;
}
} else {
cout << "NO" << endl;
}
return 0;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
You are given n points on the straight line — the positions (x-coordinates) of the cities and m points on the same line — the positions (x-coordinates) of the cellular towers. All towers work in the same way — they provide cellular network for all cities, which are located at the distance which is no more than r from this tower.
Your task is to find minimal r that each city has been provided by cellular network, i.e. for each city there is at least one cellular tower at the distance which is no more than r.
If r = 0 then a tower provides cellular network only for the point where it is located. One tower can provide cellular network for any number of cities, but all these cities must be at the distance which is no more than r from this tower.
Input
The first line contains two positive integers n and m (1 ≤ n, m ≤ 105) — the number of cities and the number of cellular towers.
The second line contains a sequence of n integers a1, a2, ..., an ( - 109 ≤ ai ≤ 109) — the coordinates of cities. It is allowed that there are any number of cities in the same point. All coordinates ai are given in non-decreasing order.
The third line contains a sequence of m integers b1, b2, ..., bm ( - 109 ≤ bj ≤ 109) — the coordinates of cellular towers. It is allowed that there are any number of towers in the same point. All coordinates bj are given in non-decreasing order.
Output
Print minimal r so that each city will be covered by cellular network.
Examples
Input
3 2
-2 2 4
-3 0
Output
4
Input
5 3
1 5 10 14 17
4 11 15
Output
3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 1e5 + 1;
int n, m;
long long Q[MAX_N], C[MAX_N];
int main() {
while (~scanf("%d%d", &n, &m)) {
for (int i = 0; i < n; i++) scanf("%I64d", C + i);
for (int i = 0; i < m; i++) scanf("%I64d", Q + i);
long long x, ans = 0;
for (int i = 0; i < n; i++) {
x = C[i];
int d = lower_bound(Q, Q + m, x) - Q;
d = d == m ? (m - 1) : d;
long long dis = min(abs(Q[d] - x), abs(Q[(d - 1) < 0 ? 0 : (d - 1)] - x));
if (dis > ans) ans = dis;
}
printf("%I64d\n", ans);
}
return 0;
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
You have a sequence A composed of N positive integers: A_{1}, A_{2}, \cdots, A_{N}.
You will now successively do the following Q operations:
* In the i-th operation, you replace every element whose value is B_{i} with C_{i}.
For each i (1 \leq i \leq Q), find S_{i}: the sum of all elements in A just after the i-th operation.
Constraints
* All values in input are integers.
* 1 \leq N, Q, A_{i}, B_{i}, C_{i} \leq 10^{5}
* B_{i} \neq C_{i}
Input
Input is given from Standard Input in the following format:
N
A_{1} A_{2} \cdots A_{N}
Q
B_{1} C_{1}
B_{2} C_{2}
\vdots
B_{Q} C_{Q}
Output
Print Q integers S_{i} to Standard Output in the following format:
S_{1}
S_{2}
\vdots
S_{Q}
Note that S_{i} may not fit into a 32-bit integer.
Examples
Input
4
1 2 3 4
3
1 2
3 4
2 4
Output
11
12
16
Input
4
1 1 1 1
3
1 2
2 1
3 5
Output
8
4
4
Input
2
1 2
3
1 100
2 100
100 1000
Output
102
200
2000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using ll=long long;
vector<int> a(100010);
ll sum;
int main(){
int n;cin>>n;
for(int i=0;i<n;++i){
int x;cin>>x;
sum+=x;
a[x]++;
}
int q;cin>>q;
for(int i=0;i<q;++i){
int b,c;cin>>b>>c;
a[c]+=a[b];
ll sa=c*a[b]-b*a[b];
sum+=sa;
a[b]=0;
cout<<sum<<endl;
}
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
A group of tourists is going to kayak and catamaran tour. A rented lorry has arrived to the boat depot to take kayaks and catamarans to the point of departure. It's known that all kayaks are of the same size (and each of them occupies the space of 1 cubic metre), and all catamarans are of the same size, but two times bigger than kayaks (and occupy the space of 2 cubic metres).
Each waterborne vehicle has a particular carrying capacity, and it should be noted that waterborne vehicles that look the same can have different carrying capacities. Knowing the truck body volume and the list of waterborne vehicles in the boat depot (for each one its type and carrying capacity are known), find out such set of vehicles that can be taken in the lorry, and that has the maximum total carrying capacity. The truck body volume of the lorry can be used effectively, that is to say you can always put into the lorry a waterborne vehicle that occupies the space not exceeding the free space left in the truck body.
Input
The first line contains a pair of integer numbers n and v (1 ≤ n ≤ 105; 1 ≤ v ≤ 109), where n is the number of waterborne vehicles in the boat depot, and v is the truck body volume of the lorry in cubic metres. The following n lines contain the information about the waterborne vehicles, that is a pair of numbers ti, pi (1 ≤ ti ≤ 2; 1 ≤ pi ≤ 104), where ti is the vehicle type (1 – a kayak, 2 – a catamaran), and pi is its carrying capacity. The waterborne vehicles are enumerated in order of their appearance in the input file.
Output
In the first line print the maximum possible carrying capacity of the set. In the second line print a string consisting of the numbers of the vehicles that make the optimal set. If the answer is not unique, print any of them.
Examples
Input
3 2
1 2
2 7
1 3
Output
7
2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct node {
int flag, v;
int q;
} a[100000 + 10];
bool cmp(node a, node b) {
if (a.flag != b.flag) return a.flag < b.flag;
if (a.flag == 1) return a.v < b.v;
return a.v > b.v;
}
int main() {
int n, v;
cin >> n >> v;
for (int i = 0; i < n; i++) {
cin >> a[i].flag >> a[i].v;
a[i].q = i + 1;
}
sort(a, a + n, cmp);
long long sum = 0;
long long v1 = 0;
int j = 0;
int i = 0;
for (; i < n; i++) {
sum += a[i].v;
v1 += a[i].flag;
if (v1 > v) {
if (v1 == v + 1) {
if (a[j].flag == 2) {
sum -= a[i].v;
i--;
break;
}
if (a[i].v <= a[j].v) {
sum -= a[i].v;
i--;
break;
}
sum -= a[j].v;
v1 -= a[j].flag;
j++;
} else {
if (a[j].flag == 2) {
sum -= a[i].v;
i--;
break;
} else if (a[j].flag == 1 && a[j + 1].flag == 1) {
if (a[j].v + a[j + 1].v < a[i].v) {
sum -= a[j].v;
sum -= a[j + 1].v;
j++;
j++;
} else {
sum -= a[i].v;
i--;
break;
}
} else
break;
}
}
}
if (i == n) i--;
cout << sum << endl;
for (int k = j; k <= i; k++) cout << a[k].q << " ";
cout << endl;
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
There are N cities in Republic of AtCoder. The size of the i-th city is A_{i}. Takahashi would like to build N-1 bidirectional roads connecting two cities so that any city can be reached from any other city by using these roads.
Assume that the cost of building a road connecting the i-th city and the j-th city is |i-j| \times D + A_{i} + A_{j}. For Takahashi, find the minimum possible total cost to achieve the objective.
Constraints
* 1 \leq N \leq 2 \times 10^5
* 1 \leq D \leq 10^9
* 1 \leq A_{i} \leq 10^9
* A_{i} and D are integers.
Input
Input is given from Standard Input in the following format:
N D
A_1 A_2 ... A_N
Output
Print the minimum possible total cost.
Examples
Input
3 1
1 100 1
Output
106
Input
3 1000
1 100 1
Output
2202
Input
6 14
25 171 7 1 17 162
Output
497
Input
12 5
43 94 27 3 69 99 56 25 8 15 46 8
Output
658
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<int, int>;
using E = pair<ll, P>;
const ll INF = 1LL << 60;
int n;
ll D;
ll a[200005];
vector< E > edges;
void solve(int L, int R) {
if (R - L <= 1) return;
int mid = (R + L) / 2;
ll lval = INF;
int lidx = -1;
for (int i = L; i < mid; i++) {
ll tmp = a[i] - D * i;
if (lval > tmp) {
lidx = i;
lval = tmp;
}
}
ll rval = INF;
int ridx = -1;
for (int i = mid; i < R; i++) {
ll tmp = a[i] + D * i;
if (rval > tmp) {
ridx = i;
rval = tmp;
}
}
for (int i = L; i < mid; i++) {
edges.emplace_back(a[i] + a[ridx] + D * (ridx - i), P(i, ridx));
}
for (int i = mid; i < R; i++) {
edges.emplace_back(a[i] + a[lidx] + D * (i - lidx), P(lidx, i));
}
solve(L, mid);
solve(mid, R);
}
struct UnionFind {
//各要素が属する集合の代表(根)を管理する
//もし、要素xが根であればdata[x]は負の値を取り、-data[x]はxが属する集合の大きさに等しい
vector<int> data;
UnionFind(int sz) : data(sz, -1) {}
bool unite(int x, int y) {
x = find(x);
y = find(y);
bool is_union = (x != y);
if (is_union) {
if (data[x] > data[y]) swap(x, y);
data[x] += data[y];
data[y] = x;
}
return is_union;
}
int find(int x) {
if (data[x] < 0) { //要素xが根である
return x;
} else {
data[x] = find(data[x]); //data[x]がxの属する集合の根でない場合、根になるよう更新される
return data[x];
}
}
bool same(int x, int y) {
return find(x) == find(y);
}
int size(int x) {
return -data[find(x)];
}
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> D;
for (int i = 0; i < n; i++) cin >> a[i];
solve(0, n);
sort(edges.begin(), edges.end());
UnionFind uf(n);
ll ans = 0;
for (E& e : edges) {
ll cost = e.first;
int u = e.second.first, v = e.second.second;
if (!uf.same(u, v)) {
uf.unite(u, v);
ans += cost;
}
}
cout << ans << endl;
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
The Kingdom of Aqua Canora Mystica is a very affluent and peaceful country, but around the kingdom, there are many evil monsters that kill people. So the king gave an order to you to kill the master monster.
You came to the dungeon where the monster lived. The dungeon consists of a grid of square cells. You explored the dungeon moving up, down, left and right. You finally found, fought against, and killed the monster.
Now, you are going to get out of the dungeon and return home. However, you found strange carpets and big rocks are placed in the dungeon, which were not there until you killed the monster. They are caused by the final magic the monster cast just before its death! Every rock occupies one whole cell, and you cannot go through that cell. Also, each carpet covers exactly one cell. Each rock is labeled by an uppercase letter and each carpet by a lowercase. Some of the rocks and carpets may have the same label.
While going around in the dungeon, you observed the following behaviors. When you enter into the cell covered by a carpet, all the rocks labeled with the corresponding letter (e.g., the rocks with ‘A’ for the carpets with ‘a’) disappear. After the disappearance, you can enter the cells where the rocks disappeared, but if you enter the same carpet cell again or another carpet cell with the same label, the rocks revive and prevent your entrance again. After the revival, you have to move on the corresponding carpet cell again in order to have those rocks disappear again.
Can you exit from the dungeon? If you can, how quickly can you exit? Your task is to write a program that determines whether you can exit the dungeon, and computes the minimum required time.
Input
The input consists of some data sets.
Each data set begins with a line containing two integers, W and H (3 ≤ W, H ≤ 30). In each of the following H lines, there are W characters, describing the map of the dungeon as W × H grid of square cells. Each character is one of the following:
* ‘@’ denoting your current position,
* ‘<’ denoting the exit of the dungeon,
* A lowercase letter denoting a cell covered by a carpet with the label of that letter,
* An uppercase letter denoting a cell occupied by a rock with the label of that letter,
* ‘#’ denoting a wall, and
* ‘.’ denoting an empty cell.
Every dungeon is surrounded by wall cells (‘#’), and has exactly one ‘@’ cell and one ‘<’ cell. There can be up to eight distinct uppercase labels for the rocks and eight distinct lowercase labels for the carpets.
You can move to one of adjacent cells (up, down, left, or right) in one second. You cannot move to wall cells or the rock cells.
A line containing two zeros indicates the end of the input, and should not be processed.
Output
For each data set, output the minimum time required to move from the ‘@’ cell to the ‘<’ cell, in seconds, in one line. If you cannot exit, output -1.
Examples
Input
8 3
########
#<[email protected]#
########
8 3
########
#<AaAa@#
########
8 4
########
#<EeEe@#
#FG.e#.#
########
8 8
########
#mmm@ZZ#
#mAAAbZ#
#mABBBZ#
#mABCCd#
#aABCDD#
#ZZcCD<#
########
0 0
Output
7
-1
7
27
Input
8 3
<[email protected]#
8 3
<AaAa@#
8 4
<EeEe@#
FG.e#.#
8 8
mmm@ZZ#
mAAAbZ#
mABBBZ#
mABCCd#
aABCDD#
ZZcCD<#
0 0
Output
7
-1
7
27
### Response
```cpp
#include<iostream>
#include<queue>
#include<cctype>
#include<map>
using namespace std;
struct S{
int y,x,t,b;
};
int main(){
for(int W,H;cin>>W>>H,W;){
char g[30][31];
map<char,int> m;
queue<S> que;
for(int i=0;i<H;i++){
cin>>g[i];
for(int j=0;j<W;j++){
if(g[i][j]=='@'){
que.push({i,j,0,0});
}else if(islower(g[i][j])){
if(!m.count(g[i][j])){
int s=m.size();
m[g[i][j]]=s;
}
}
}
}
bool p[30][30][1<<8]={};
while(!que.empty()){
S cs=que.front();
if(g[cs.y][cs.x]=='<')break;
que.pop();
if(p[cs.y][cs.x][cs.b]++)continue;
for(int i=0;i<4;i++){
int ny=cs.y+(~i&i-1);
int nx=cs.x+(i?2-i:0);
char c=g[cs.y][cs.x];
if(c!='#'&&!(isupper(c)&&(!m.count(tolower(c))||!(cs.b>>m[tolower(c)]&1)))){
int nb=cs.b;
if(islower(c)){
nb^=1<<m[c];
}
que.push({ny,nx,cs.t+1,nb});
}
}
}
cout<<(que.empty()?-1:que.front().t)<<endl;
}
}
``` |
### Prompt
Create a solution in cpp for the following problem:
An X-layered kagami mochi (X ≥ 1) is a pile of X round mochi (rice cake) stacked vertically where each mochi (except the bottom one) has a smaller diameter than that of the mochi directly below it. For example, if you stack three mochi with diameters of 10, 8 and 6 centimeters from bottom to top in this order, you have a 3-layered kagami mochi; if you put just one mochi, you have a 1-layered kagami mochi.
Lunlun the dachshund has N round mochi, and the diameter of the i-th mochi is d_i centimeters. When we make a kagami mochi using some or all of them, at most how many layers can our kagami mochi have?
Constraints
* 1 ≤ N ≤ 100
* 1 ≤ d_i ≤ 100
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
d_1
:
d_N
Output
Print the maximum number of layers in a kagami mochi that can be made.
Examples
Input
4
10
8
8
6
Output
3
Input
3
15
15
15
Output
1
Input
7
50
30
50
100
50
80
30
Output
4
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n,a,s[1000],b[1000];
int main()
{
cin>>n;
for(int i=1;i<=n;i++)
{
cin>>s[i];
b[s[i]]=1;
}
for(int i=1;i<=100;i++) a+=b[i];
cout<<a;
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
You are given two binary strings a and b of the same length. You can perform the following two operations on the string a:
* Swap any two bits at indices i and j respectively (1 ≤ i, j ≤ n), the cost of this operation is |i - j|, that is, the absolute difference between i and j.
* Select any arbitrary index i (1 ≤ i ≤ n) and flip (change 0 to 1 or 1 to 0) the bit at this index. The cost of this operation is 1.
Find the minimum cost to make the string a equal to b. It is not allowed to modify string b.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^6) — the length of the strings a and b.
The second and third lines contain strings a and b respectively.
Both strings a and b have length n and contain only '0' and '1'.
Output
Output the minimum cost to make the string a equal to b.
Examples
Input
3
100
001
Output
2
Input
4
0101
0011
Output
1
Note
In the first example, one of the optimal solutions is to flip index 1 and index 3, the string a changes in the following way: "100" → "000" → "001". The cost is 1 + 1 = 2.
The other optimal solution is to swap bits and indices 1 and 3, the string a changes then "100" → "001", the cost is also |1 - 3| = 2.
In the second example, the optimal solution is to swap bits at indices 2 and 3, the string a changes as "0101" → "0011". The cost is |2 - 3| = 1.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
using ll = long long;
using ld = long double;
using ii = pair<ll, ll>;
using iii = tuple<ll, ll, ll>;
using matrix = vector<vector<ll>>;
using arr = vector<ll>;
using vs = vector<string>;
using pv = vector<ii>;
using umap = unordered_map<ll, ll>;
void showArr(arr a) {
for (auto i : a) cout << i << " ";
cout << endl;
}
ll dx[] = {-1, 1, -1, 1, 0, 0, -1, 1};
ll dy[] = {-1, 1, 0, 0, -1, 1, 1, -1};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << setprecision(25);
ll n;
cin >> n;
string a, b;
cin >> a >> b;
ll cost = 0;
for (int i = 0; i < n; i++) {
if (a[i] != b[i]) {
if (i + 1 < n and a[i + 1] == b[i] and b[i + 1] == a[i]) {
swap(a[i], a[i + 1]);
cost++;
} else {
cost++;
a[i] = b[i];
}
}
}
cout << cost << endl;
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
You are given a huge decimal number consisting of n digits. It is guaranteed that this number has no leading zeros. Each digit of this number is either 0 or 1.
You may perform several (possibly zero) operations with this number. During each operation you are allowed to change any digit of your number; you may change 0 to 1 or 1 to 0. It is possible that after some operation you can obtain a number with leading zeroes, but it does not matter for this problem.
You are also given two integers 0 ≤ y < x < n. Your task is to calculate the minimum number of operations you should perform to obtain the number that has remainder 10^y modulo 10^x. In other words, the obtained number should have remainder 10^y when divided by 10^x.
Input
The first line of the input contains three integers n, x, y (0 ≤ y < x < n ≤ 2 ⋅ 10^5) — the length of the number and the integers x and y, respectively.
The second line of the input contains one decimal number consisting of n digits, each digit of this number is either 0 or 1. It is guaranteed that the first digit of the number is 1.
Output
Print one integer — the minimum number of operations you should perform to obtain the number having remainder 10^y modulo 10^x. In other words, the obtained number should have remainder 10^y when divided by 10^x.
Examples
Input
11 5 2
11010100101
Output
1
Input
11 5 1
11010100101
Output
3
Note
In the first example the number will be 11010100100 after performing one operation. It has remainder 100 modulo 100000.
In the second example the number will be 11010100010 after performing three operations. It has remainder 10 modulo 100000.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, x, y;
string second;
cin >> n >> x >> y >> second;
int ans = 0;
for (int i = n - x; i < n; ++i) {
if (i == n - y - 1)
ans += (second[i] != '1');
else
ans += second[i] != '0';
}
cout << ans << "\n";
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
You are given an array a_1, a_2, ... , a_n. Array is good if for each pair of indexes i < j the condition j - a_j ≠ i - a_i holds. Can you shuffle this array so that it becomes good? To shuffle an array means to reorder its elements arbitrarily (leaving the initial order is also an option).
For example, if a = [1, 1, 3, 5], then shuffled arrays [1, 3, 5, 1], [3, 5, 1, 1] and [5, 3, 1, 1] are good, but shuffled arrays [3, 1, 5, 1], [1, 1, 3, 5] and [1, 1, 5, 3] aren't.
It's guaranteed that it's always possible to shuffle an array to meet this condition.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
The first line of each test case contains one integer n (1 ≤ n ≤ 100) — the length of array a.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 100).
Output
For each test case print the shuffled version of the array a which is good.
Example
Input
3
1
7
4
1 1 3 5
6
3 2 1 5 6 4
Output
7
1 5 1 3
2 4 6 1 3 5
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int t, n;
int main() {
cin >> t;
while (t--) {
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
sort(a.rbegin(), a.rend());
for (int i = 0; i < n; i++) cout << a[i] << " ";
cout << endl;
}
return 0;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
Little Petya likes numbers a lot. Recently his mother has presented him a collection of n non-negative integers. There's only one thing Petya likes more than numbers: playing with little Masha. He immediately decided to give a part of his new collection to her. To make the game even more interesting, Petya decided to give Masha such collection of numbers for which the following conditions fulfill:
* Let's introduce x1 to denote the xor of all numbers Petya has got left; and let's introduce x2 to denote the xor of all numbers he gave to Masha. Value (x1 + x2) must be as large as possible.
* If there are multiple ways to divide the collection so that the previous condition fulfilled, then Petya minimizes the value x1.
The xor operation is a bitwise excluding "OR", that is denoted as "xor" in the Pascal language and "^" in C/C++/Java.
Help Petya divide the collection as described above. If there are multiple suitable ways to divide it, find any of them. Please note that after Petya gives a part of his numbers to Masha, he may have no numbers left. The reverse situation is also possible, when Petya gives nothing to Masha. In both cases we must assume that the xor of an empty set of numbers equals 0.
Input
The first line contains integer n (1 ≤ n ≤ 105), showing how many numbers Petya's mother gave him. The second line contains the actual space-separated numbers. They are all integer, non-negative and do not exceed 1018.
Output
Print n space-separated integers, the i-th of them should equal either 1, if Petya keeps the number that follows i-th in his collection, or it should equal 2, if Petya gives the corresponding number to Masha. The numbers are indexed in the order in which they are given in the input.
Examples
Input
6
1 2 3 4 5 6
Output
2 2 2 2 2 2
Input
3
1000000000000 1000000000000 1000000000000
Output
2 2 2
Input
8
1 1 2 2 3 3 4 4
Output
1 2 1 2 2 2 1 2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
bitset<N> b[65];
int n, m, q[65], ans[N];
long long a[N], s;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%lld", a + i);
s ^= a[i];
}
for (int j = 0; j < 2; ++j) {
for (int k = 63; k >= 0; --k) {
if ((s >> k & 1) == j) {
for (int i = 1; i <= n; ++i) b[m][i] = a[i] >> k & 1;
b[m][0] = j ^ 1;
for (int i = 0; i < m; ++i)
if (b[m][q[i]]) b[m] ^= b[i];
q[m] = n + 1;
for (int i = 1; i <= n; ++i)
if (b[m][i]) {
q[m] = i;
break;
}
if (q[m] > n) continue;
for (int i = 0; i < m; ++i)
if (b[i][q[m]]) b[i] ^= b[m];
++m;
}
}
}
for (int i = 0; i < m; ++i) ans[q[i]] = b[i][0];
for (int i = 1; i <= n; ++i) printf("%d ", 2 - ans[i]);
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
This is an output-only problem. You shouldn't read anything from the input.
In short, your task is to simulate multiplication by using only comparison (x < y) and addition (x + y). There is no input in this problem, you just print a sequence of operations.
Imagine that there is a big array a[0], a[1], ..., a[N-1] of length N. The first two values are initially two non-negative integers A and B (which are unknown to you), the other elements are zeros. Your goal is to get the product A \cdot B in a[2] at the end.
You are allowed operations of two types, with the following format (where 0 \leq i, j, k < N):
* `+ i j k` — applies operation a[k] = a[i] + a[j].
* `< i j k` — applies operation a[k] = a[i] < a[j]. That is, if a[i] < a[j] then a[k] becomes 1, otherwise it becomes 0.
You can use at most Q operations. Elements of a can't exceed V. Indices (i, j, k) don't have to be distinct. It's allowed to modify any element of the array (including the first two). The actual checker simulates the process for multiple pairs (A, B) within a single test. Each time, the checker chooses values A and B, creates the array a = [A, B, 0, 0, \ldots, 0], applies all your operations and ensures that a[2] = A \cdot B.
Constraints
* 0 \leq A, B \leq 10^9
* N = Q = 200\,000
* V = 10^{19} = 10\,000\,000\,000\,000\,000\,000
Input
The Standard Input is empty.
Output
In the first line, print the number of operations. Each operation should then be printed in a single line of format `+ i j k` or `< i j k`.
Example
Input
Output
### Response
```cpp
#if 1
#ifdef LOCAL
#define _GLIBCXX_DEBUG 1
#define dbg(...) cerr << "LINE(" << __LINE__ << ") -> [" << #__VA_ARGS__ << "]: [", DBG(__VA_ARGS__)
#else
#define dbg(...) 0
#endif
#include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for(int i = a; i < (b); ++i)
#define sz(x) (int)(x).size()
#define all(x) begin(x), end(x)
#define FOR(i,a,b) for (int i = (a); i < (b); ++i)
#define F0R(i,a) FOR(i,0,a)
typedef string str;
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
#define ts to_string
str ts(char c) { return str(1,c); }
str ts(bool b) { return b ? "true" : "false"; }
str ts(const char* s) { return (str)s; }
str ts(str s) { return s; }
template<class A> str ts(complex<A> c) { stringstream ss; ss << c; return ss.str(); }
str ts(vector<bool> v) { str res = "{"; F0R(i,sz(v)) res += char('0'+v[i]); res += "}"; return res; }
template<size_t SZ> str ts(bitset<SZ> b) { str res = ""; F0R(i,SZ) res += char('0'+b[i]); return res; }
template<class A, class B> str ts(pair<A,B> p);
template<class T> str ts(T v) { bool fst = 1; str res = "{"; for (const auto& x: v) {if (!fst) res += ", "; fst = 0; res += ts(x);} res += "}"; return res;}
template<class A, class B> str ts(pair<A,B> p) {return "("+ts(p.f)+", "+ts(p.s)+")"; }
template<class A> void pr(A x) { cout << ts(x); }
template<class H, class... T> void pr(const H& h, const T&... t) { pr(h); pr(t...); }
void ps() { pr("\n"); }
template<class H, class... T> void ps(const H& h, const T&... t) { pr(h); if (sizeof...(t)) pr(" "); ps(t...); }
void DBG() { cerr << "]" << endl; }
template<class H, class... T> void DBG(H h, T... t) {cerr << ts(h); if (sizeof...(t)) cerr << ", "; DBG(t...); }
#endif
int unused = 1000;
int zero = 199999;
int one = 3;
vector< pair<char, pair<int, pair<int, int> > > > ops;
void compare(int dest, int i, int j) {
ops.push_back({'<', {i, {j,dest}}});
// cout << "< " << dest << ' ' << i << ' ' << j << '\n';
}
void add(int dest, int i, int j) {
ops.push_back({'+', {i, {j,dest}}});
// cout << "+ " << dest << ' ' << i << ' ' << j << '\n';
}
void do_the_and(int dest, int i, int j) {
int temp1 = unused++;
int temp2 = unused++;
compare(temp1, i, one);
compare(temp2, j, one);
add(temp2, temp1, temp2);
compare(dest, temp2, one);
}
int pow2(int v) {
return 3+v;
}
void convert(int src, int start) {
int curval = unused++;
for (int p = 30; p >= 0; p--) {
int dest = start + p;
int temp1 = unused++;
int temp2 = unused++;
add(temp1, curval, pow2(p));
compare(dest, temp1, src);
add(temp2, dest, zero);
for (int j = 0; j < p; j++) {
add(temp2,temp2,temp2);
}
add(curval,curval,temp2);
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
compare(3, 3, 0);
for (int i = 4; i < 35; i++) {
add(i, i-1, i-1);
}
add(0, 0, one);
add(1, 1, one);
convert(0, 100000);
convert(1, 110000);
for (int fin = 60; fin >= 0; fin--) {
add(2, 2, 2);
for (int p1 = 30; p1 >= 0; p1--) {
for (int p2 = 30; p2 >= 0; p2--) if (p1+p2 == fin) {
int idx1 = 100000 + p1;
int idx2 = 110000 + p2;
int nloc = unused++;
do_the_and(nloc, idx1, idx2);
add(2, 2, nloc);
}
}
}
// cout << unused << endl;
cout << sz(ops) << '\n';
for (int i = 0; i < sz(ops); i++) {
cout << ops[i].first << ' ' << ops[i].second.first << ' ' << ops[i].second.second.first << ' ' << ops[i].second.second.second << '\n';
}
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
As the guys fried the radio station facilities, the school principal gave them tasks as a punishment. Dustin's task was to add comments to nginx configuration for school's website. The school has n servers. Each server has a name and an ip (names aren't necessarily unique, but ips are). Dustin knows the ip and name of each server. For simplicity, we'll assume that an nginx command is of form "command ip;" where command is a string consisting of English lowercase letter only, and ip is the ip of one of school servers.
<image>
Each ip is of form "a.b.c.d" where a, b, c and d are non-negative integers less than or equal to 255 (with no leading zeros). The nginx configuration file Dustin has to add comments to has m commands. Nobody ever memorizes the ips of servers, so to understand the configuration better, Dustin has to comment the name of server that the ip belongs to at the end of each line (after each command). More formally, if a line is "command ip;" Dustin has to replace it with "command ip; #name" where name is the name of the server with ip equal to ip.
Dustin doesn't know anything about nginx, so he panicked again and his friends asked you to do his task for him.
Input
The first line of input contains two integers n and m (1 ≤ n, m ≤ 1000).
The next n lines contain the names and ips of the servers. Each line contains a string name, name of the server and a string ip, ip of the server, separated by space (1 ≤ |name| ≤ 10, name only consists of English lowercase letters). It is guaranteed that all ip are distinct.
The next m lines contain the commands in the configuration file. Each line is of form "command ip;" (1 ≤ |command| ≤ 10, command only consists of English lowercase letters). It is guaranteed that ip belongs to one of the n school servers.
Output
Print m lines, the commands in the configuration file after Dustin did his task.
Examples
Input
2 2
main 192.168.0.2
replica 192.168.0.1
block 192.168.0.1;
proxy 192.168.0.2;
Output
block 192.168.0.1; #replica
proxy 192.168.0.2; #main
Input
3 5
google 8.8.8.8
codeforces 212.193.33.27
server 138.197.64.57
redirect 138.197.64.57;
block 8.8.8.8;
cf 212.193.33.27;
unblock 8.8.8.8;
check 138.197.64.57;
Output
redirect 138.197.64.57; #server
block 8.8.8.8; #google
cf 212.193.33.27; #codeforces
unblock 8.8.8.8; #google
check 138.197.64.57; #server
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, mp;
cin >> n >> mp;
map<string, string> m;
while (n--) {
string name, ip;
cin >> name >> ip;
m.insert(make_pair(ip, name));
}
while (mp--) {
string com, ip1, ans;
map<string, string>::iterator it;
cin >> com >> ip1;
string ip2 = ip1.substr(0, ip1.length() - 1);
for (it = m.begin(); it != m.end(); it++) {
string s = it->first;
if (s == ip2) {
ans = it->second;
break;
}
}
cout << com << " " << ip1 << " #" << ans << endl;
}
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
Billy investigates the question of applying greedy algorithm to different spheres of life. At the moment he is studying the application of greedy algorithm to the problem about change. There is an amount of n coins of different face values, and the coins of each value are not limited in number. The task is to collect the sum x with the minimum amount of coins. Greedy algorithm with each its step takes the coin of the highest face value, not exceeding x. Obviously, if among the coins' face values exists the face value 1, any sum x can be collected with the help of greedy algorithm. However, greedy algorithm does not always give the optimal representation of the sum, i.e. the representation with the minimum amount of coins. For example, if there are face values {1, 3, 4} and it is asked to collect the sum 6, greedy algorithm will represent the sum as 4 + 1 + 1, while the optimal representation is 3 + 3, containing one coin less. By the given set of face values find out if there exist such a sum x that greedy algorithm will collect in a non-optimal way. If such a sum exists, find out the smallest of these sums.
Input
The first line contains an integer n (1 ≤ n ≤ 400) — the amount of the coins' face values. The second line contains n integers ai (1 ≤ ai ≤ 109), describing the face values. It is guaranteed that a1 > a2 > ... > an and an = 1.
Output
If greedy algorithm collects any sum in an optimal way, output -1. Otherwise output the smallest sum that greedy algorithm collects in a non-optimal way.
Examples
Input
5
25 10 5 2 1
Output
-1
Input
3
4 3 1
Output
6
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, ans, a[500], b[500], c[500];
int deal(int x) {
int ans = 0;
for (int i = 1; i <= n; i++) {
b[i] = x / a[i];
ans += b[i];
x %= a[i];
if (!x) break;
}
return ans;
}
bool cmp(int a, int b) { return a > b; }
int main() {
cin.sync_with_stdio(false);
ans = 2100000007;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n, cmp);
for (int i = 1; i < n; i++) {
deal(a[i] - 1);
for (int i = 1; i <= n; i++) c[i] = b[i];
for (int j = i + 1; j <= n; j++) {
int temp = 0, temp2 = 0;
for (int k = 1; k <= j; k++) {
temp2 += a[k] * c[k];
temp += c[k];
}
temp2 += a[j], temp++;
if (deal(temp2) > temp) ans = min(temp2, ans);
}
}
if (ans == 2100000007)
cout << -1 << endl;
else
cout << ans << endl;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
Recently a lot of students were enrolled in Berland State University. All students were divided into groups according to their education program. Some groups turned out to be too large to attend lessons in the same auditorium, so these groups should be divided into two subgroups. Your task is to help divide the first-year students of the computer science faculty.
There are t new groups belonging to this faculty. Students have to attend classes on three different subjects — maths, programming and P. E. All classes are held in different places according to the subject — maths classes are held in auditoriums, programming classes are held in computer labs, and P. E. classes are held in gyms.
Each group should be divided into two subgroups so that there is enough space in every auditorium, lab or gym for all students of the subgroup. For the first subgroup of the i-th group, maths classes are held in an auditorium with capacity of a_{i, 1} students; programming classes are held in a lab that accomodates up to b_{i, 1} students; and P. E. classes are held in a gym having enough place for c_{i, 1} students. Analogically, the auditorium, lab and gym for the second subgroup can accept no more than a_{i, 2}, b_{i, 2} and c_{i, 2} students, respectively.
As usual, some students skip some classes. Each student considers some number of subjects (from 0 to 3) to be useless — that means, he skips all classes on these subjects (and attends all other classes). This data is given to you as follows — the i-th group consists of:
1. d_{i, 1} students which attend all classes;
2. d_{i, 2} students which attend all classes, except for P. E.;
3. d_{i, 3} students which attend all classes, except for programming;
4. d_{i, 4} students which attend only maths classes;
5. d_{i, 5} students which attend all classes, except for maths;
6. d_{i, 6} students which attend only programming classes;
7. d_{i, 7} students which attend only P. E.
There is one more type of students — those who don't attend any classes at all (but they, obviously, don't need any place in auditoriums, labs or gyms, so the number of those students is insignificant in this problem).
Your task is to divide each group into two subgroups so that every auditorium (or lab, or gym) assigned to each subgroup has enough place for all students from this subgroup attending the corresponding classes (if it is possible). Each student of the i-th group should belong to exactly one subgroup of the i-th group; it is forbidden to move students between groups.
Input
The first line contains one integer t (1 ≤ t ≤ 300) — the number of groups.
Then the descriptions of groups follow. The description of the i-th group consists of three lines:
* the first line contains three integers a_{i, 1}, b_{i, 1} and c_{i, 1} (1 ≤ a_{i, 1}, b_{i, 1}, c_{i, 1} ≤ 3000) — the capacity of the auditorium, lab and gym assigned to the first subgroup of the i-th group, respectively;
* the second line contains three integers a_{i, 2}, b_{i, 2} and c_{i, 2} (1 ≤ a_{i, 2}, b_{i, 2}, c_{i, 2} ≤ 3000) — the capacity of the auditorium, lab and gym assigned to the second subgroup of the i-th group, respectively;
* the third line contains integers d_{i, 1}, d_{i, 2}, ..., d_{i, 7} (0 ≤ d_{i, j} ≤ 3000) — the number of students belonging to each of the seven aforementioned types in the i-th group. It is not guaranteed that the sum of these values is positive — a group can consist entirely of students that don't attend classes at all.
It is guaranteed that the total number of students in all groups is not greater than 3000.
Output
For each group, print the result of its division as follows:
* if it is impossible to divide the group, print one integer -1;
* otherwise print seven integers f_{i, 1}, f_{i, 2}, ..., f_{i, 7} (0 ≤ f_{i, j} ≤ d_{i, j}) — the number of students the first, second, ..., seventh type in the first subgroup of the i-th group (all other students will be assigned to the second subgroup). If there are multiple answers, print any of them.
Example
Input
3
9 4 13
1 10 3
1 2 3 4 5 6 7
9 4 13
1 10 3
2 1 3 4 5 6 7
1 2 3
4 5 6
0 0 0 0 0 0 0
Output
1 1 3 4 2 0 7
-1
0 0 0 0 0 0 0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
double const eps = 1e-7;
struct LP {
int n;
vector<vector<double> > e;
void adeq(vector<double> const &v) { e.push_back(v); }
int bad() {
for (int i = 1; i < (int)(e.size()); ++i)
if (e[i][n] < -eps) {
for (int j = 0; j < (int)(n); ++j)
if (e[i][j] < -eps) return j;
return -2;
}
return -1;
}
int getkl() {
for (int i = 0; i < (int)(n); ++i)
if (e[0][i] > eps) return i;
return -1;
}
int getmn(int j) {
int an = 0;
double mn = 1e18;
for (int i = 1; i < (int)(e.size()); ++i)
if (e[i][j] > eps) {
double t = e[i][n] / e[i][j];
if (t < mn) mn = t, an = i;
}
return an;
}
void kl(int j) {
int i = getmn(j);
double t = e[i][j];
for (int k = 0; k < (int)(e[i].size()); ++k) e[i][k] /= t;
for (int k = 0; k < (int)(e.size()); ++k)
if (k != i) {
double z = e[k][j];
for (int w = 0; w < (int)(e[k].size()); ++w) e[k][w] -= z * e[i][w];
}
}
void pl() {
int t = e[0].size() - 1;
n = e[0].size() + e.size() - 2;
for (int i = 0; i < (int)(e.size()); ++i) e[i].resize(n + 1);
for (int i = 1; i < (int)(e.size()); ++i) swap(e[i][t], e[i][n]);
for (int i = 1; i < (int)(e.size()); ++i) e[i][t + i - 1] = 1.0;
}
pair<double, bool> solve() {
pl();
int j;
while ((j = bad()) >= 0) kl(j);
if (j == -2) return make_pair(0.0, false);
while ((j = getkl()) >= 0) kl(j);
return make_pair(-e[0][n], true);
}
vector<double> gtval(int m) {
vector<char> vis(e.size());
vis[0] = true;
vector<double> an(m);
for (int i = 0; i < (int)(m); ++i)
if (abs(e[0][i]) < eps) {
int j = 0;
for (int k = 1; k < (int)(e.size()); ++k)
if (abs(e[k][i]) > eps) {
if (j) {
j = 0;
break;
}
j = k;
}
if (!vis[j]) {
an[i] = e[j][n] / e[j][i];
vis[j] = true;
}
}
return an;
}
};
int g[2][3], fr[8];
bool ok(vector<int> const &v) {
int sm[2][3] = {};
for (int i = 0; i < (int)(v.size()); ++i)
for (int j = 0; j < (int)(3); ++j)
if (i + 1 >> j & 1) {
sm[0][j] += v[i];
sm[1][j] += fr[i + 1] - v[i];
}
for (int i = 0; i < (int)(3); ++i)
if (g[0][2 - i] < sm[0][i] || g[1][2 - i] < sm[1][i]) return false;
return true;
}
void solve() {
for (int i = 0; i < (int)(2); ++i)
for (int j = 0; j < (int)(3); ++j) scanf("%d", g[i] + j);
for (int i = 7; i > 0; --i) scanf("%d", fr + i);
LP s;
vector<double> v(8);
s.adeq(v);
for (int i = 0; i < (int)(7); ++i) {
for (int j = 0; j < (int)(7); ++j) v[j] = 0;
v[i] = 1;
v[7] = fr[i + 1];
s.adeq(v);
v[i] = -1;
v[7] = 0;
s.adeq(v);
}
for (int i = 0; i < (int)(3); ++i) {
for (int j = 1; j < (int)(8); ++j) v[j - 1] = j >> i & 1;
v[7] = g[0][2 - i];
s.adeq(v);
int z = 0;
for (int j = 1; j < (int)(8); ++j)
if (v[j - 1]) {
v[j - 1] *= -1;
z += fr[j];
}
v[7] = -(z - g[1][2 - i]);
s.adeq(v);
}
if (!s.solve().second) {
printf("-1\n");
return;
}
vector<double> val = s.gtval(7);
vector<int> an(7);
for (int i = 0; i < (int)(1 << 7); ++i) {
for (int j = 0; j < (int)(7); ++j)
an[j] = val[j] + 0.5 + (i >> j & 1 ? -eps : eps);
if (ok(an)) break;
}
if (!ok(an)) {
printf("-1\n");
return;
}
for (int i = 0; i < (int)(7); ++i) printf("%d ", an[6 - i]);
printf("\n");
}
int main() {
int t;
scanf("%d", &t);
while (t--) solve();
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
You are given four integers n, c_0, c_1 and h and a binary string s of length n.
A binary string is a string consisting of characters 0 and 1.
You can change any character of the string s (the string should be still binary after the change). You should pay h coins for each change.
After some changes (possibly zero) you want to buy the string. To buy the string you should buy all its characters. To buy the character 0 you should pay c_0 coins, to buy the character 1 you should pay c_1 coins.
Find the minimum number of coins needed to buy the string.
Input
The first line contains a single integer t (1 ≤ t ≤ 10) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of the description of each test case contains four integers n, c_{0}, c_{1}, h (1 ≤ n, c_{0}, c_{1}, h ≤ 1000).
The second line of the description of each test case contains the binary string s of length n.
Output
For each test case print a single integer — the minimum number of coins needed to buy the string.
Example
Input
6
3 1 1 1
100
5 10 100 1
01010
5 10 1 1
11111
5 1 10 1
11111
12 2 1 10
101110110101
2 100 1 10
00
Output
3
52
5
10
16
22
Note
In the first test case, you can buy all characters and pay 3 coins, because both characters 0 and 1 costs 1 coin.
In the second test case, you can firstly change 2-nd and 4-th symbols of the string from 1 to 0 and pay 2 coins for that. Your string will be 00000. After that, you can buy the string and pay 5 ⋅ 10 = 50 coins for that. The total number of coins paid will be 2 + 50 = 52.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, c, a, h;
cin >> n >> c >> a >> h;
string s;
cin >> s;
int sum = 0;
if (c == a) {
cout << (n * c) << endl;
} else {
if (abs(c - a) > h) {
if (c < a) {
for (int i = 0; i < s.length(); i++) {
if (s[i] == '0')
sum = sum + c;
else
sum = sum + c + h;
}
} else {
for (int i = 0; i < s.length(); i++) {
if (s[i] == '1')
sum = sum + a;
else
sum = sum + a + h;
}
}
cout << sum << endl;
} else {
for (int i = 0; i < s.length(); i++) {
if (s[i] == '0')
sum = sum + c;
else
sum = sum + a;
}
cout << sum << endl;
}
}
}
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
Valery is a PE teacher at a school in Berland. Soon the students are going to take a test in long jumps, and Valery has lost his favorite ruler!
However, there is no reason for disappointment, as Valery has found another ruler, its length is l centimeters. The ruler already has n marks, with which he can make measurements. We assume that the marks are numbered from 1 to n in the order they appear from the beginning of the ruler to its end. The first point coincides with the beginning of the ruler and represents the origin. The last mark coincides with the end of the ruler, at distance l from the origin. This ruler can be repesented by an increasing sequence a1, a2, ..., an, where ai denotes the distance of the i-th mark from the origin (a1 = 0, an = l).
Valery believes that with a ruler he can measure the distance of d centimeters, if there is a pair of integers i and j (1 ≤ i ≤ j ≤ n), such that the distance between the i-th and the j-th mark is exactly equal to d (in other words, aj - ai = d).
Under the rules, the girls should be able to jump at least x centimeters, and the boys should be able to jump at least y (x < y) centimeters. To test the children's abilities, Valery needs a ruler to measure each of the distances x and y.
Your task is to determine what is the minimum number of additional marks you need to add on the ruler so that they can be used to measure the distances x and y. Valery can add the marks at any integer non-negative distance from the origin not exceeding the length of the ruler.
Input
The first line contains four positive space-separated integers n, l, x, y (2 ≤ n ≤ 105, 2 ≤ l ≤ 109, 1 ≤ x < y ≤ l) — the number of marks, the length of the ruler and the jump norms for girls and boys, correspondingly.
The second line contains a sequence of n integers a1, a2, ..., an (0 = a1 < a2 < ... < an = l), where ai shows the distance from the i-th mark to the origin.
Output
In the first line print a single non-negative integer v — the minimum number of marks that you need to add on the ruler.
In the second line print v space-separated integers p1, p2, ..., pv (0 ≤ pi ≤ l). Number pi means that the i-th mark should be at the distance of pi centimeters from the origin. Print the marks in any order. If there are multiple solutions, print any of them.
Examples
Input
3 250 185 230
0 185 250
Output
1
230
Input
4 250 185 230
0 20 185 250
Output
0
Input
2 300 185 230
0 300
Output
2
185 230
Note
In the first sample it is impossible to initially measure the distance of 230 centimeters. For that it is enough to add a 20 centimeter mark or a 230 centimeter mark.
In the second sample you already can use the ruler to measure the distances of 185 and 230 centimeters, so you don't have to add new marks.
In the third sample the ruler only contains the initial and the final marks. We will need to add two marks to be able to test the children's skills.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long mn, mx, n, k, imx, imn, l, x, y, a[300000], kx, ky, ans1, ans2, ans3,
ans4;
map<long long, long long> mp;
int main() {
cin >> n >> l >> x >> y;
for (int i = 1; i <= n; i++) {
cin >> a[i], mp[a[i]] = 1;
}
sort(a + 1, a + 1 + n);
for (int i = 1; i <= n; i++) {
if (mp[a[i] - x] == 1) kx++;
if (mp[a[i] - y] == 1) ky++;
if (mp[a[i] - y + x] == 1 && (a[i] - y >= 0)) {
ans1 = a[i] - y;
}
if (mp[a[i] - x + y] == 1 && (a[i] + y <= l)) {
ans2 = a[i] + y;
}
if (mp[a[i] + x + y] == 1) {
ans3 = a[i] + x;
}
if (mp[a[i] - x - y] == 1) {
ans4 = a[i] - x;
}
}
if (kx != 0 && ky != 0)
cout << 0;
else if (kx != 0 || ky != 0) {
cout << 1 << '\n';
if (kx != 0)
cout << y;
else
cout << x;
} else if (ans1 != 0) {
cout << 1 << '\n';
cout << ans1;
} else if (ans2 != 0) {
cout << 1 << '\n';
cout << ans2;
} else if (ans3 != 0) {
cout << 1 << '\n';
cout << ans3;
} else if (ans4 != 0) {
cout << 1 << '\n';
cout << ans4;
} else {
cout << 2 << '\n';
cout << x << ' ' << y;
}
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Divide and rule
Taro, Hanako, and Jiro rule the JAG Kingdom together. There are N cities in the JAG Kingdom, some of which are connected by two-way roads. You can always reach all the other cities from any city via one or more roads.
One day, Taro and Hanako finally made a mistake and decided to share the city and govern it. However, I don't even like the fact that the city governed by Taro and the city governed by Hanako are directly connected by a single road because they have become so bad. Therefore, we decided to share the governing towns so as to satisfy the following conditions.
* Any pair of towns governed by Taro and Hanako are not directly connected by roads. This is because the relationship between Taro and Hanako is insanely bad.
* Towns governed by the same person are not directly connected by roads. This is to encourage diplomacy by obliging the passage under the control of others.
* The total number of towns governed by Taro and the total number of towns governed by Hanako must be the same. This is because if the total number is not equal, the relationship between Taro and Hanako will be even worse. Here, Mr. Jiro is very open-minded, so the total number of cities governed by Mr. Jiro can be any number.
If the division meets the above conditions, the three people can be convinced to rule, and even if there are no cities governed by someone, there is no complaint. At this time, create a program that enumerates all possible numbers as the total number of cities governed by Mr. Taro (= the total number of cities governed by Mr. Hanako).
Input
The input consists of multiple datasets. The maximum number of datasets is 50. Each data set is represented in the following format.
> N M u1 v1 ... uM vM
The first line consists of two integers N (2 ≤ N ≤ 103) and M (1 ≤ M ≤ 103), which represent the number of cities and the number of roads, respectively. The i-th line of the following M lines consists of two integers ui and vi (1 ≤ ui <vi ≤ N), indicating that the i-th road connects the city ui and the city vi in both directions. Here, it is guaranteed that one city can always reach all other cities via one or more roads. Also, no multiple roads connecting pairs of the same city will be given. That is, (ui, vi) ≠ (uj, vj) is satisfied for all 1 ≤ i <j ≤ M.
The end of the input is represented by a line of two zeros.
Output
For each dataset, if there are K possible total numbers of cities governed by Taro, first output K on the first line, then output the possible total number on each line in ascending order.
Sample Input
6 7
1 2
14
twenty three
twenty five
3 4
4 5
4 6
twenty one
1 2
3 3
1 2
13
twenty three
4 3
1 2
twenty three
3 4
5 4
1 2
twenty three
3 4
4 5
0 0
Output for the Sample Input
2
1
2
0
0
1
1
1
1
Example
Input
6 7
1 2
1 4
2 3
2 5
3 4
4 5
4 6
2 1
1 2
3 3
1 2
1 3
2 3
4 3
1 2
2 3
3 4
5 4
1 2
2 3
3 4
4 5
0 0
Output
2
1
2
0
0
1
1
1
1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
while(cin >> n >> m, n) {
vector<vector<int>> g(n);
for(int i = 0; i < m; ++i) {
int a, b; cin >> a >> b;
g[a - 1].push_back(b - 1);
g[b - 1].push_back(a - 1);
}
vector<int> col(n, -1), cnt(2);
function<void(int, int)> coloring =
[&] (int v, int c) {
if(col[v] != -1 && col[v] != c) throw runtime_error("");
if(col[v] != -1) return;
col[v] = c;
cnt[c] += 1;
for(auto to : g[v]) {
coloring(to, !c);
}
};
try {
coloring(0, 0);
} catch (...) {
cout << 0 << endl;
continue;
}
set<int> s;
if(cnt[0] % 2 == 0) s.insert(cnt[0] / 2);
if(cnt[1] % 2 == 0) s.insert(cnt[1] / 2);
cout << s.size() << endl;
for(auto x : s) {
cout << x << endl;
}
}
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
Lenny had an n × m matrix of positive integers. He loved the matrix so much, because each row of the matrix was sorted in non-decreasing order. For the same reason he calls such matrices of integers lovely.
One day when Lenny was at school his little brother was playing with Lenny's matrix in his room. He erased some of the entries of the matrix and changed the order of some of its columns. When Lenny got back home he was very upset. Now Lenny wants to recover his matrix.
Help him to find an order for the columns of the matrix so that it's possible to fill in the erased entries of the matrix to achieve a lovely matrix again. Note, that you can fill the erased entries of the matrix with any integers.
Input
The first line of the input contains two positive integers n and m (1 ≤ n·m ≤ 105). Each of the next n lines contains m space-separated integers representing the matrix. An integer -1 shows an erased entry of the matrix. All other integers (each of them is between 0 and 109 inclusive) represent filled entries.
Output
If there exists no possible reordering of the columns print -1. Otherwise the output should contain m integers p1, p2, ..., pm showing the sought permutation of columns. So, the first column of the lovely matrix will be p1-th column of the initial matrix, the second column of the lovely matrix will be p2-th column of the initial matrix and so on.
Examples
Input
3 3
1 -1 -1
1 2 1
2 -1 1
Output
3 1 2
Input
2 3
1 2 2
2 5 4
Output
1 3 2
Input
2 3
1 2 3
3 2 1
Output
-1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
bool debug = true;
template <typename T1, typename T2>
ostream& operator<<(ostream& os, pair<T1, T2> ptt) {
os << ptt.first << "," << ptt.second;
return os;
}
template <typename T>
ostream& operator<<(ostream& os, vector<T> vt) {
os << "{";
for (int i = 0; i < vt.size(); i++) {
os << vt[i] << " ";
}
os << "}";
return os;
}
int n, m;
vector<int> a[100005];
vector<int> nei[500005];
int deg[500005];
map<int, int> vn[100005];
int vnc;
const int MAX = 1e9 + 7;
int getVN(int ln, int x) {
if (vn[ln].count(x)) {
} else {
vn[ln][x] = vnc;
vnc++;
assert(vnc <= 500000);
}
return vn[ln][x];
}
void add(int x, int y) {
nei[x].push_back(y);
deg[y]++;
}
int main(int argc, char* argv[]) {
ios::sync_with_stdio(0);
cin >> n >> m;
vnc = m;
for (int i = 0; i < n; i++) {
a[i].resize(m);
for (int j = 0; j < m; j++) {
cin >> a[i][j];
if (a[i][j] != -1) {
a[i][j]++;
}
}
}
for (int i = 0; i < n; i++) {
vector<pair<int, int> > p;
for (int j = 0; j < m; j++) {
if (a[i][j] != -1) {
p.push_back(make_pair(a[i][j], j));
}
}
sort(p.begin(), p.end());
for (int j = 0; j < p.size(); j++) {
add(getVN(i, p[j].first), p[j].second);
add(p[j].second, getVN(i, p[j].first + MAX));
}
}
for (int i = 0; i < n; i++) {
int last = -1;
for (pair<int, int> x : vn[i]) {
if (x.first > MAX) {
break;
}
if (last != -1) {
add(getVN(i, last + MAX), x.second);
}
last = x.first;
}
}
queue<int> q;
for (int i = 0; i < vnc; i++) {
if (deg[i] == 0) {
q.push(i);
}
}
vector<int> ans;
while (!q.empty()) {
int last = q.front();
q.pop();
if (last < m) {
ans.push_back(last + 1);
}
for (int to : nei[last]) {
deg[to]--;
if (deg[to] == 0) {
q.push(to);
}
}
}
if (ans.size() != m) {
cout << "-1";
} else {
for (int x : ans) {
cout << x << endl;
}
}
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
You are given a special jigsaw puzzle consisting of n⋅ m identical pieces. Every piece has three tabs and one blank, as pictured below.
<image>
The jigsaw puzzle is considered solved if the following conditions hold:
1. The pieces are arranged into a grid with n rows and m columns.
2. For any two pieces that share an edge in the grid, a tab of one piece fits perfectly into a blank of the other piece.
Through rotation and translation of the pieces, determine if it is possible to solve the jigsaw puzzle.
Input
The test consists of multiple test cases. The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next t lines contain descriptions of test cases.
Each test case contains two integers n and m (1 ≤ n,m ≤ 10^5).
Output
For each test case output a single line containing "YES" if it is possible to solve the jigsaw puzzle, or "NO" otherwise. You can print each letter in any case (upper or lower).
Example
Input
3
1 3
100000 100000
2 2
Output
YES
NO
YES
Note
For the first test case, this is an example solution:
<image>
For the second test case, we can show that no solution exists.
For the third test case, this is an example solution:
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
if (min(n, m) == 1)
cout << "YES" << endl;
else if (n == 2 && m == 2)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
Petya got interested in grammar on his third year in school. He invented his own language called Petya's. Petya wanted to create a maximally simple language that would be enough to chat with friends, that's why all the language's grammar can be described with the following set of rules:
* There are three parts of speech: the adjective, the noun, the verb. Each word in his language is an adjective, noun or verb.
* There are two genders: masculine and feminine. Each word in his language has gender either masculine or feminine.
* Masculine adjectives end with -lios, and feminine adjectives end with -liala.
* Masculine nouns end with -etr, and feminime nouns end with -etra.
* Masculine verbs end with -initis, and feminime verbs end with -inites.
* Thus, each word in the Petya's language has one of the six endings, given above. There are no other endings in Petya's language.
* It is accepted that the whole word consists of an ending. That is, words "lios", "liala", "etr" and so on belong to the Petya's language.
* There aren't any punctuation marks, grammatical tenses, singular/plural forms or other language complications.
* A sentence is either exactly one valid language word or exactly one statement.
Statement is any sequence of the Petya's language, that satisfy both conditions:
* Words in statement follow in the following order (from the left to the right): zero or more adjectives followed by exactly one noun followed by zero or more verbs.
* All words in the statement should have the same gender.
After Petya's friend Vasya wrote instant messenger (an instant messaging program) that supported the Petya's language, Petya wanted to add spelling and grammar checking to the program. As Vasya was in the country and Petya didn't feel like waiting, he asked you to help him with this problem. Your task is to define by a given sequence of words, whether it is true that the given text represents exactly one sentence in Petya's language.
Input
The first line contains one or more words consisting of lowercase Latin letters. The overall number of characters (including letters and spaces) does not exceed 105.
It is guaranteed that any two consecutive words are separated by exactly one space and the input data do not contain any other spaces. It is possible that given words do not belong to the Petya's language.
Output
If some word of the given text does not belong to the Petya's language or if the text contains more that one sentence, print "NO" (without the quotes). Otherwise, print "YES" (without the quotes).
Examples
Input
petr
Output
YES
Input
etis atis animatis etis atis amatis
Output
NO
Input
nataliala kataliala vetra feinites
Output
YES
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
char st[100005];
int word[100005];
int wordCount = 0;
int parse(string s) {
int pol = -1;
int type = -1;
int l = s.length();
if (l < 3) return -1;
string temp;
temp = s.substr(l - 3, 3);
if (!temp.compare("etr")) {
pol = 1;
type = 1;
} else if (l < 4)
return -1;
else {
temp = s.substr(l - 4, 4);
if (!temp.compare("etra")) {
pol = 0;
type = 1;
} else if (!temp.compare("lios")) {
pol = 1;
type = 0;
} else if (l < 5)
return -1;
else {
temp = s.substr(l - 5, 5);
if (!temp.compare("liala")) {
pol = 0;
type = 0;
} else if (l < 6)
return -1;
else {
temp = s.substr(l - 6, 6);
if (!temp.compare("initis")) {
pol = 1;
type = 2;
} else if (!temp.compare("inites")) {
pol = 0;
type = 2;
}
}
}
}
if (pol < 0 || type < 0) return -1;
return pol * 10 + type;
}
int main() {
gets(st);
string tmp = "";
int len = strlen(st);
for (int i = 0; i < len; i++) {
if (st[i] == ' ' || i == len - 1) {
if (i == len - 1) tmp += st[i];
int j = parse(tmp);
word[wordCount++] = j;
if (j < 0) {
cout << "NO";
return 0;
}
tmp = "";
} else
tmp += st[i];
}
if (wordCount > 1) {
int p = word[0] / 10;
for (int i = 1; i < wordCount; i++) {
if (word[i] / 10 != p) {
cout << "NO";
return 0;
}
}
int j = 0, kl = 0;
int t = 0;
while (j < wordCount && word[j] % 10 == t) j++;
if (j == wordCount) {
cout << "NO";
return 0;
}
kl = 0;
t++;
while (j < wordCount && word[j] % 10 == t) {
j++;
kl++;
}
if (kl != 1) {
cout << "NO";
return 0;
}
t++;
while (j < wordCount && word[j] % 10 == t) j++;
if (j != wordCount) {
cout << "NO";
return 0;
}
}
cout << "YES";
return 0;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
Amugae has a hotel consisting of 10 rooms. The rooms are numbered from 0 to 9 from left to right.
The hotel has two entrances — one from the left end, and another from the right end. When a customer arrives to the hotel through the left entrance, they are assigned to an empty room closest to the left entrance. Similarly, when a customer arrives at the hotel through the right entrance, they are assigned to an empty room closest to the right entrance.
One day, Amugae lost the room assignment list. Thankfully Amugae's memory is perfect, and he remembers all of the customers: when a customer arrived, from which entrance, and when they left the hotel. Initially the hotel was empty. Write a program that recovers the room assignment list from Amugae's memory.
Input
The first line consists of an integer n (1 ≤ n ≤ 10^5), the number of events in Amugae's memory.
The second line consists of a string of length n describing the events in chronological order. Each character represents:
* 'L': A customer arrives from the left entrance.
* 'R': A customer arrives from the right entrance.
* '0', '1', ..., '9': The customer in room x (0, 1, ..., 9 respectively) leaves.
It is guaranteed that there is at least one empty room when a customer arrives, and there is a customer in the room x when x (0, 1, ..., 9) is given. Also, all the rooms are initially empty.
Output
In the only line, output the hotel room's assignment status, from room 0 to room 9. Represent an empty room as '0', and an occupied room as '1', without spaces.
Examples
Input
8
LLRL1RL1
Output
1010000011
Input
9
L0L0LLRR9
Output
1100000010
Note
In the first example, hotel room's assignment status after each action is as follows.
* First of all, all rooms are empty. Assignment status is 0000000000.
* L: a customer arrives to the hotel through the left entrance. Assignment status is 1000000000.
* L: one more customer from the left entrance. Assignment status is 1100000000.
* R: one more customer from the right entrance. Assignment status is 1100000001.
* L: one more customer from the left entrance. Assignment status is 1110000001.
* 1: the customer in room 1 leaves. Assignment status is 1010000001.
* R: one more customer from the right entrance. Assignment status is 1010000011.
* L: one more customer from the left entrance. Assignment status is 1110000011.
* 1: the customer in room 1 leaves. Assignment status is 1010000011.
So after all, hotel room's final assignment status is 1010000011.
In the second example, hotel room's assignment status after each action is as follows.
* L: a customer arrives to the hotel through the left entrance. Assignment status is 1000000000.
* 0: the customer in room 0 leaves. Assignment status is 0000000000.
* L: a customer arrives to the hotel through the left entrance. Assignment status is 1000000000 again.
* 0: the customer in room 0 leaves. Assignment status is 0000000000.
* L: a customer arrives to the hotel through the left entrance. Assignment status is 1000000000.
* L: one more customer from the left entrance. Assignment status is 1100000000.
* R: one more customer from the right entrance. Assignment status is 1100000001.
* R: one more customer from the right entrance. Assignment status is 1100000011.
* 9: the customer in room 9 leaves. Assignment status is 1100000010.
So after all, hotel room's final assignment status is 1100000010.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long int n, arr[10];
char ch;
int main() {
cin >> n;
while (n--) {
cin >> ch;
if (ch == 'L') {
int i;
for (i = 0; i < 10; i++) {
if (arr[i] == 0) {
arr[i] = 1;
break;
}
}
} else if (ch == 'R') {
int i;
for (i = 9; i >= 0; i--) {
if (arr[i] == 0) {
arr[i] = 1;
break;
}
}
} else if (isdigit(ch)) {
arr[ch - 48] = 0;
}
}
for (int i = 0; i < 10; i++) cout << arr[i];
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
A laser beam generator, a target object and some mirrors are placed on a plane. The mirrors stand upright on the plane, and both sides of the mirrors are flat and can reflect beams. To point the beam at the target, you may set the beam to several directions because of different reflections. Your job is to find the shortest beam path from the generator to the target and answer the length of the path.
Figure G-1 shows examples of possible beam paths, where the bold line represents the shortest one.
<image>
Figure G-1: Examples of possible paths
Input
The input consists of a number of datasets. The end of the input is indicated by a line containing a zero.
Each dataset is formatted as follows. Each value in the dataset except n is an integer no less than 0 and no more than 100.
> n
> PX1 PY1 QX1 QY1
> ...
> PXn PYn QXn QYn
> TX TY
> LX LY
>
The first line of a dataset contains an integer n (1 ≤ n ≤ 5), representing the number of mirrors. The following n lines list the arrangement of mirrors on the plane. The coordinates (PXi, PYi) and (QXi, QYi) represent the positions of both ends of the mirror. Mirrors are apart from each other. The last two lines represent the target position (TX, TY) and the position of the beam generator (LX, LY). The positions of the target and the generator are apart from each other, and these positions are also apart from mirrors.
The sizes of the target object and the beam generator are small enough to be ignored. You can also ignore the thicknesses of mirrors.
In addition, you can assume the following conditions on the given datasets.
* There is at least one possible path from the beam generator to the target.
* The number of reflections along the shortest path is less than 6.
* The shortest path does not cross or touch a plane containing a mirror surface at any points within 0.001 unit distance from either end of the mirror.
* Even if the beam could arbitrarily select reflection or passage when it reaches each plane containing a mirror surface at a point within 0.001 unit distance from one of the mirror ends, any paths from the generator to the target would not be shorter than the shortest path.
* When the beam is shot from the generator in an arbitrary direction and it reflects on a mirror or passes the mirror within 0.001 unit distance from the mirror, the angle θ formed by the beam and the mirror satisfies sin(θ) > 0.1, until the beam reaches the 6th reflection point (exclusive).
Figure G-1 corresponds to the first dataset of the Sample Input below. Figure G-2 shows the shortest paths for the subsequent datasets of the Sample Input.
<image>
Figure G-2: Examples of the shortest paths
Output
For each dataset, output a single line containing the length of the shortest path from the beam generator to the target. The value should not have an error greater than 0.001. No extra characters should appear in the output.
Sample Input
2
30 10 30 75
60 30 60 95
90 0
0 100
1
20 81 90 90
10 90
90 10
2
10 0 10 58
20 20 20 58
0 70
30 0
4
8 0 8 60
16 16 16 48
16 10 28 30
16 52 28 34
24 0
24 64
5
8 0 8 60
16 16 16 48
16 10 28 30
16 52 28 34
100 0 100 50
24 0
24 64
0
Output for the Sample Input
180.27756377319946
113.13708498984761
98.99494936611666
90.50966799187809
90.50966799187809
Example
Input
2
30 10 30 75
60 30 60 95
90 0
0 100
1
20 81 90 90
10 90
90 10
2
10 0 10 58
20 20 20 58
0 70
30 0
4
8 0 8 60
16 16 16 48
16 10 28 30
16 52 28 34
24 0
24 64
5
8 0 8 60
16 16 16 48
16 10 28 30
16 52 28 34
100 0 100 50
24 0
24 64
0
Output
180.27756377319946
113.13708498984761
98.99494936611666
90.50966799187809
90.50966799187809
### Response
```cpp
#include <iostream>
#include <iomanip>
#include <vector>
#include <algorithm>
#include <tuple>
#include <cmath>
using namespace std;
const double EPS = 1e-8;
const double INF = 1e10;
struct Point {
double x, y;
Point() : x(0), y(0) { }
Point(double x, double y) : x(x), y(y) { }
Point operator+(const Point &p) const { return Point(x + p.x, y + p.y); }
Point operator-(const Point &p) const { return Point(x - p.x, y - p.y); }
Point operator*(double s) const { return Point(x * s, y * s); }
Point operator/(double s) const { return Point(x / s, y / s); }
Point &operator+=(const Point &p){ x += p.x; y += p.y; return *this; }
Point &operator-=(const Point &p){ x -= p.x; y -= p.y; return *this; }
Point &operator*=(double s){ x *= s; y *= s; return *this; }
Point &operator/=(double s){ x /= s; y /= s; return *this; }
bool operator==(const Point &p) const { return x == p.x && y == p.y; }
bool operator!=(const Point &p) const { return x != p.x || y != p.y; }
bool operator<(const Point &p) const {
return (x == p.x) ? (y < p.y) : (x < p.x);
}
};
inline Point operator*(double s, const Point &p){ return p * s; }
inline double norm(const Point &p){ return p.x * p.x + p.y * p.y; }
inline double abs(const Point &p){ return sqrt(norm(p)); }
inline double arg(const Point &p){ return atan2(p.y, p.x); }
inline Point unit(const Point &p){ return p / abs(p); }
inline Point ortho(const Point &p){ return Point(-p.y, p.x); }
inline double cross(const Point &a, const Point &b){
return a.x * b.y - a.y * b.x;
}
inline double dot(const Point &a, const Point &b){
return a.x * b.x + a.y * b.y;
}
inline int ccw(const Point &a, const Point &b, const Point &c){
const Point d = b - a, e = c - a;
if(cross(d, e) > 0.0){ return 1; }
if(cross(d, e) < 0.0){ return -1; }
if(dot(d, e) < 0.0){ return 2; }
if(abs(d) < abs(e)){ return -2; }
return 0;
}
struct Line {
Point a, b;
Line() : a(), b() { }
Line(const Point &a, const Point &b) : a(a), b(b) { }
bool operator==(const Line &l) const { return a == l.a && b == l.b; }
bool operator!=(const Line &l) const { return a != l.a || b != l.b; }
bool operator<(const Line &l) const {
return (a == l.a) ? (b < l.b) : (a < l.a);
}
};
inline Point direction(const Line &l){ return unit(l.b - l.a); }
inline int is_parallel(const Line &a, const Line &b){
// 0: not parallel, 1: parallel, -1: same line
const double s = cross(direction(a), direction(b));
if(s >= EPS){ return 0; }
const double t = cross(direction(b), a.b - b.a);
return (t >= EPS) ? 1 : -1;
}
inline Line bisect(const Point &a, const Point &b){
const Point &p = (a + b) * 0.5;
return Line(p, unit(ortho(b - a)));
}
inline Point projection(const Line &l, const Point &p){
double t = dot(p - l.a, l.b - l.a) / norm(l.b - l.a);
return l.a + t * (l.b - l.a);
}
inline Point reflection(const Line &l, const Point &p){
return p + 2.0 * (projection(l, p) - p);
}
inline Point crossing_point(const Line &a, const Line &b){
const double x = cross(a.b - a.a, b.b - b.a);
const double y = cross(a.b - a.a, a.b - b.a);
return Point(b.a + (y / x) * (b.b - b.a));
}
struct Segment : public Line {
Segment() : Line() { }
Segment(const Point &a, const Point &b) : Line(a, b) { }
};
inline bool intersect(const Segment &a, const Segment &b){
if(ccw(a.a, a.b, b.a) * ccw(a.a, a.b, b.b) > 0){ return false; }
if(ccw(b.a, b.b, a.a) * ccw(b.a, b.b, a.b) > 0){ return false; }
return true;
}
typedef tuple<double, int> tdi;
typedef tuple<Segment, int, int> tsii;
double solve(
int depth, int prev, const Point &s, const Point &t,
const vector<Segment> &mirrors,
vector<tsii> &imag_mirrors, vector<int> &history)
{
const int n = mirrors.size(), m = imag_mirrors.size();
const Segment st(s, t);
for(int i = 0; i < n; ++i){
if(i != prev){ imag_mirrors.push_back(tsii(mirrors[i], i, depth)); }
}
vector<tdi> crossing_order;
for(int i = 0; i < imag_mirrors.size(); ++i){
if(intersect(st, get<0>(imag_mirrors[i]))){
const Point p = crossing_point(st, get<0>(imag_mirrors[i]));
crossing_order.push_back(tdi(norm(p - s), i));
}
}
sort(crossing_order.begin(), crossing_order.end());
int reflected = 0;
bool accept = true;
for(int i = 0; i < crossing_order.size(); ++i){
const tsii &mirror = imag_mirrors[get<1>(crossing_order[i])];
const int level = get<2>(mirror);
const int mask = (1 << level) - 1;
if((reflected & mask) != mask){ continue; }
if(reflected & (1 << level)){ continue; }
if(level >= depth || history[level] != get<1>(mirror)){
accept = false;
break;
}
reflected |= (1 << level);
}
if(reflected != ((1 << depth) - 1)){ accept = false; }
double answer = INF;
if(accept){ answer = abs(t - s); }
if(depth >= 5){
imag_mirrors.resize(m);
return answer;
}
for(int i = 0; i < n; ++i){
if(i == prev){ continue; }
vector<Segment> next_mirrors(n);
for(int j = 0; j < n; ++j){
next_mirrors[j] = Segment(
reflection(mirrors[i], mirrors[j].a),
reflection(mirrors[i], mirrors[j].b));
}
history.push_back(i);
const Point next_t = reflection(mirrors[i], t);
answer = min(answer, solve(
depth + 1, i, s, next_t, next_mirrors, imag_mirrors, history));
history.pop_back();
}
imag_mirrors.resize(m);
return answer;
}
int main(){
ios_base::sync_with_stdio(false);
cout << setiosflags(ios::fixed) << setprecision(10);
while(true){
int n;
cin >> n;
if(n == 0){ break; }
vector<Segment> mirrors(n);
for(int i = 0; i < n; ++i){
Segment &s = mirrors[i];
cin >> s.a.x >> s.a.y >> s.b.x >> s.b.y;
}
Point s, t;
cin >> s.x >> s.y >> t.x >> t.y;
vector<tsii> imag_mirrors;
vector<int> history;
cout << solve(0, -1, s, t, mirrors, imag_mirrors, history) << endl;
}
return 0;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
Priority queue is a container of elements which the element with the highest priority should be extracted first.
For $n$ priority queues $Q_i$ ($i = 0, 1, ..., n-1$) of integers, perform a sequence of the following operations.
* insert($t$, $x$): Insert $x$ to $Q_t$.
* getMax($t$): Report the maximum value in $Q_t$. If $Q_t$ is empty, do nothing.
* deleteMax($t$): Delete the maximum element from $Q_t$. If $Q_t$ is empty, do nothing.
In the initial state, all queues are empty.
Constraints
* $1 \leq n \leq 1,000$
* $1 \leq q \leq 200,000$
* $-1,000,000,000 \leq x \leq 1,000,000,000$
Input
The input is given in the following format.
$n \; q$
$query_1$
$query_2$
:
$query_q$
Each query $query_i$ is given by
0 $t$ $x$
or
1 $t$
or
2 $t$
where the first digits 0, 1 and 2 represent insert, getMax and deleteMax operations respectively.
Output
For each getMax operation, print an integer in a line.
Example
Input
2 10
0 0 3
0 0 9
0 0 1
1 0
2 0
1 0
0 0 4
1 0
0 1 8
1 1
Output
9
3
4
8
### Response
```cpp
#include <iostream>
#include<list>
#include<vector>
#include<stack>
#include<queue>
using namespace std;
int main()
{
int n,q;
cin>>n>>q;
priority_queue<int> que[n];
int tp1,tp2,a;
while(q--){
cin>>tp1;
switch(tp1){
case 0:
cin>>tp2>>a;
que[tp2].push(a);
break;
case 1:
cin>>tp2;
if(!que[tp2].empty())cout<<que[tp2].top()<<"\n";
break;
case 2:
cin>>tp2;
if(!que[tp2].empty())que[tp2].pop();
break;
}
}
}
//list<int> lit;
//list<int>::iterator it;
//int main()
//{
// lit.clear();
// int t,tp,a;
// it=lit.begin();
// cin>>t;
// while(t--){
// cin>>tp;
// switch(tp){
// case 0:
// cin>>a;
// lit.insert(it,a);
// break;
// case 1:
// cin>>a;
// if(a<0){
// while(a++){
// if(it!=lit.end())it++;
// }
// }
// else if(a>0){
// while(a--){
// if(it!=lit.begin())it--;
// }
// }
// break;
// case 2:
// lit.erase(--it);
// break;
// }
// }
// lit.reverse();
// for(it=lit.begin();it!=lit.end();it++){
//
// cout<<*it<<"\n";
// }
//}
``` |
### Prompt
Please create a solution in CPP to the following problem:
You are given two strings s and t. Both strings have length n and consist of lowercase Latin letters. The characters in the strings are numbered from 1 to n.
You can successively perform the following move any number of times (possibly, zero):
* swap any two adjacent (neighboring) characters of s (i.e. for any i = \{1, 2, ..., n - 1\} you can swap s_i and s_{i + 1}).
You can't apply a move to the string t. The moves are applied to the string s one after another.
Your task is to obtain the string t from the string s. Find any way to do it with at most 10^4 such moves.
You do not have to minimize the number of moves, just find any sequence of moves of length 10^4 or less to transform s into t.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 50) — the length of strings s and t.
The second line of the input contains the string s consisting of n lowercase Latin letters.
The third line of the input contains the string t consisting of n lowercase Latin letters.
Output
If it is impossible to obtain the string t using moves, print "-1".
Otherwise in the first line print one integer k — the number of moves to transform s to t. Note that k must be an integer number between 0 and 10^4 inclusive.
In the second line print k integers c_j (1 ≤ c_j < n), where c_j means that on the j-th move you swap characters s_{c_j} and s_{c_j + 1}.
If you do not need to apply any moves, print a single integer 0 in the first line and either leave the second line empty or do not print it at all.
Examples
Input
6
abcdef
abdfec
Output
4
3 5 4 5
Input
4
abcd
accd
Output
-1
Note
In the first example the string s changes as follows: "abcdef" → "abdcef" → "abdcfe" → "abdfce" → "abdfec".
In the second example there is no way to transform the string s into the string t through any allowed moves.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, i, j, k;
string s, t;
vector<int> ans;
bool solved = true;
cin >> n >> s >> t;
for (i = 0; i < n; i++) {
bool matched = false;
for (j = i; j < n; j++) {
if (s[j] == t[i]) {
matched = true;
for (k = j - 1; k >= i; k--) {
ans.push_back(k);
swap(s[k], s[k + 1]);
}
break;
}
}
if (!matched) {
solved = false;
break;
}
}
if (!solved)
cout << "-1\n";
else {
cout << ans.size() << "\n";
for (auto p : ans) cout << p + 1 << " ";
cout << "\n";
}
return 0;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
Zane once had a good sequence a consisting of n integers a1, a2, ..., an — but he has lost it.
A sequence is said to be good if and only if all of its integers are non-negative and do not exceed 109 in value.
<image>
However, Zane remembers having played around with his sequence by applying m operations to it.
There are two types of operations:
1. Find the maximum value of integers with indices i such that l ≤ i ≤ r, given l and r.
2. Assign d as the value of the integer with index k, given k and d.
After he finished playing, he restored his sequence to the state it was before any operations were applied. That is, sequence a was no longer affected by the applied type 2 operations. Then, he lost his sequence at some time between now and then.
Fortunately, Zane remembers all the operations and the order he applied them to his sequence, along with the distinct results of all type 1 operations. Moreover, among all good sequences that would produce the same results when the same operations are applied in the same order, he knows that his sequence a has the greatest cuteness.
We define cuteness of a sequence as the bitwise OR result of all integers in such sequence. For example, the cuteness of Zane's sequence a is a1 OR a2 OR ... OR an.
Zane understands that it might not be possible to recover exactly the lost sequence given his information, so he would be happy to get any good sequence b consisting of n integers b1, b2, ..., bn that:
1. would give the same results when the same operations are applied in the same order, and
2. has the same cuteness as that of Zane's original sequence a.
If there is such a sequence, find it. Otherwise, it means that Zane must have remembered something incorrectly, which is possible.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 3·105) — the number of integers in Zane's original sequence and the number of operations that have been applied to the sequence, respectively.
The i-th of the following m lines starts with one integer ti (<image>) — the type of the i-th operation.
If the operation is type 1 (ti = 1), then three integers li, ri, and xi follow (1 ≤ li ≤ ri ≤ n, 0 ≤ xi ≤ 109) — the leftmost index to be considered, the rightmost index to be considered, and the maximum value of all integers with indices between li and ri, inclusive, respectively.
If the operation is type 2 (ti = 2), then two integers ki and di follow (1 ≤ ki ≤ n, 0 ≤ di ≤ 109) — meaning that the integer with index ki should become di after this operation.
It is guaranteed that xi ≠ xj for all pairs (i, j) where 1 ≤ i < j ≤ m and ti = tj = 1.
The operations are given in the same order they were applied. That is, the operation that is given first was applied first, the operation that is given second was applied second, and so on.
Output
If there does not exist a valid good sequence, print "NO" (without quotation marks) in the first line.
Otherwise, print "YES" (without quotation marks) in the first line, and print n space-separated integers b1, b2, ..., bn (0 ≤ bi ≤ 109) in the second line.
If there are multiple answers, print any of them.
Examples
Input
5 4
1 1 5 19
1 2 5 1
2 5 100
1 1 5 100
Output
YES
19 0 0 0 1
Input
5 2
1 1 5 0
1 1 5 100
Output
NO
Note
In the first sample, it is easy to verify that this good sequence is valid. In particular, its cuteness is 19 OR 0 OR 0 OR 0 OR 1 = 19.
In the second sample, the two operations clearly contradict, so there is no such good sequence.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
map<int, int> cnt;
int t[300005 * 4];
int a[300005];
int n, m;
struct note {
int Type, x, y, z;
} s[300005];
void buildnew(int v, int l, int r) {
if (l == r) {
t[v] = a[l];
return;
}
int mid = (l + r) >> 1;
buildnew(v << 1, l, mid);
buildnew(v << 1 | 1, mid + 1, r);
t[v] = max(t[v << 1], t[v << 1 | 1]);
}
void change(int v, int l, int r, int x, int y) {
if (l == r) {
t[v] = y;
return;
}
int mid = (l + r) >> 1;
if (x <= mid)
change(v << 1, l, mid, x, y);
else
change(v << 1 | 1, mid + 1, r, x, y);
t[v] = max(t[v << 1], t[v << 1 | 1]);
}
int getmax(int v, int l, int r, int x, int y) {
if (l == x && r == y) return t[v];
int mid = (l + r) >> 1;
if (y <= mid)
return getmax(v << 1, l, mid, x, y);
else if (x > mid)
return getmax(v << 1 | 1, mid + 1, r, x, y);
else
return max(getmax(v << 1, l, mid, x, mid),
getmax(v << 1 | 1, mid + 1, r, mid + 1, y));
}
void build(int v, int l, int r) {
t[v] = 2e9;
if (l == r) return;
int mid = (l + r) >> 1;
build(v << 1, l, mid);
build(v << 1 | 1, mid + 1, r);
}
void mntag(int v, int l, int r, int x, int y, int z) {
if (l == x && r == y) {
t[v] = min(t[v], z);
return;
}
int mid = (l + r) >> 1;
if (y <= mid)
mntag(v << 1, l, mid, x, y, z);
else if (x > mid)
mntag(v << 1 | 1, mid + 1, r, x, y, z);
else
mntag(v << 1, l, mid, x, mid, z),
mntag(v << 1 | 1, mid + 1, r, mid + 1, y, z);
}
int getmin(int v, int l, int r, int x) {
if (l == r) return t[v];
int mid = (l + r) >> 1;
if (x <= mid)
return min(t[v], getmin(v << 1, l, mid, x));
else
return min(t[v], getmin(v << 1 | 1, mid + 1, r, x));
}
int main() {
scanf("%d%d", &n, &m);
build(1, 1, n);
memset(a, 255, sizeof(a));
for (int i = 1; i <= m; i++) {
int Type, x, y, z;
scanf("%d", &Type);
if (Type == 1) {
scanf("%d%d%d", &x, &y, &z);
mntag(1, 1, n, x, y, z);
} else {
scanf("%d%d", &x, &y);
if (a[x] == -1) a[x] = getmin(1, 1, n, x);
}
s[i].Type = Type;
s[i].x = x;
s[i].y = y;
s[i].z = z;
}
for (int i = 1; i <= n; i++)
if (a[i] == -1) a[i] = getmin(1, 1, n, i);
buildnew(1, 1, n);
for (int i = 1; i <= m; i++) {
if (s[i].Type == 1) {
if (getmax(1, 1, n, s[i].x, s[i].y) != s[i].z) {
puts("NO");
return 0;
}
} else {
change(1, 1, n, s[i].x, s[i].y);
}
}
puts("YES");
for (int i = 1; i <= n; i++) cnt[a[i]]++;
if (cnt[2e9] >= 2) {
bool fi = 0;
for (int i = 1; i <= n; i++) {
if (a[i] != 2e9) {
printf("%d ", a[i]);
continue;
}
if (!fi) {
fi = 1;
a[i] = (1 << 29) - 1;
} else
a[i] = 1e9;
printf("%d ", a[i]);
}
return 0;
}
int own = 0;
for (int i = 1; i <= n; i++) {
if (a[i] == 0 || a[i] == 2e9) continue;
--cnt[a[i]];
if (cnt[a[i]] > 0) {
int wz = 0;
for (int j = 0; j <= 30; j++) {
if ((1 << j) <= a[i]) wz = j;
}
a[i] = (1 << wz) - 1;
own |= a[i];
} else
own |= a[i];
}
int ned = 0;
for (int i = 30; i >= 0; i--) {
if (own & (1 << i)) continue;
if (ned + (1 << i) > 1e9) continue;
ned += 1 << i;
}
for (int i = 1; i <= n; i++) {
if (a[i] == 2e9) a[i] = ned;
printf("%d ", a[i]);
}
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
T is a complete binary tree consisting of n vertices. It means that exactly one vertex is a root, and each vertex is either a leaf (and doesn't have children) or an inner node (and has exactly two children). All leaves of a complete binary tree have the same depth (distance from the root). So n is a number such that n + 1 is a power of 2.
In the picture you can see a complete binary tree with n = 15.
<image>
Vertices are numbered from 1 to n in a special recursive way: we recursively assign numbers to all vertices from the left subtree (if current vertex is not a leaf), then assign a number to the current vertex, and then recursively assign numbers to all vertices from the right subtree (if it exists). In the picture vertices are numbered exactly using this algorithm. It is clear that for each size of a complete binary tree exists exactly one way to give numbers to all vertices. This way of numbering is called symmetric.
You have to write a program that for given n answers q queries to the tree.
Each query consists of an integer number ui (1 ≤ ui ≤ n) and a string si, where ui is the number of vertex, and si represents the path starting from this vertex. String si doesn't contain any characters other than 'L', 'R' and 'U', which mean traverse to the left child, to the right child and to the parent, respectively. Characters from si have to be processed from left to right, considering that ui is the vertex where the path starts. If it's impossible to process a character (for example, to go to the left child of a leaf), then you have to skip it. The answer is the number of vertex where the path represented by si ends.
For example, if ui = 4 and si = «UURL», then the answer is 10.
Input
The first line contains two integer numbers n and q (1 ≤ n ≤ 1018, q ≥ 1). n is such that n + 1 is a power of 2.
The next 2q lines represent queries; each query consists of two consecutive lines. The first of these two lines contains ui (1 ≤ ui ≤ n), the second contains non-empty string si. si doesn't contain any characters other than 'L', 'R' and 'U'.
It is guaranteed that the sum of lengths of si (for each i such that 1 ≤ i ≤ q) doesn't exceed 105.
Output
Print q numbers, i-th number must be the answer to the i-th query.
Example
Input
15 2
4
UURL
8
LRLLLLLLLL
Output
10
5
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long btcnt(long long n) {
long long k = 0;
while (n % 2 == 0) {
k++;
n /= 2;
}
return k;
}
long long arr[100];
int main() {
long long n, q;
cin >> n >> q;
long long mx = btcnt(n + 1) - 1;
arr[0] = 1;
for (long long i = 1; i <= 64; i++) {
arr[i] = arr[i - 1] * 2;
}
while (q--) {
long long pvt;
cin >> pvt;
string s;
cin >> s;
for (int i = 0; i < s.size(); i++) {
long long temp = btcnt(pvt);
if (s[i] == 'U') {
if (temp == mx) continue;
long long a, b;
a = pvt + arr[temp];
b = pvt - arr[temp];
if (a % arr[temp + 1] == 0 && a % arr[temp + 2] != 0)
pvt = a;
else
pvt = b;
} else if (s[i] == 'L') {
if (temp == 0)
continue;
else {
pvt -= arr[temp - 1];
}
} else {
if (temp == 0)
continue;
else {
pvt += arr[temp - 1];
}
}
}
cout << pvt << endl;
}
return 0;
}
``` |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.