text
stringlengths 424
69.5k
|
|---|
### Prompt
Please create a solution in CPP to the following problem:
A girl named Xenia has a cupboard that looks like an arc from ahead. The arc is made of a semicircle with radius r (the cupboard's top) and two walls of height h (the cupboard's sides). The cupboard's depth is r, that is, it looks like a rectangle with base r and height h + r from the sides. The figure below shows what the cupboard looks like (the front view is on the left, the side view is on the right).
<image>
Xenia got lots of balloons for her birthday. The girl hates the mess, so she wants to store the balloons in the cupboard. Luckily, each balloon is a sphere with radius <image>. Help Xenia calculate the maximum number of balloons she can put in her cupboard.
You can say that a balloon is in the cupboard if you can't see any part of the balloon on the left or right view. The balloons in the cupboard can touch each other. It is not allowed to squeeze the balloons or deform them in any way. You can assume that the cupboard's walls are negligibly thin.
Input
The single line contains two integers r, h (1 ≤ r, h ≤ 107).
Output
Print a single integer — the maximum number of balloons Xenia can put in the cupboard.
Examples
Input
1 1
Output
3
Input
1 2
Output
5
Input
2 1
Output
2
### Response
```cpp
#include <bits/stdc++.h>
int main() {
int R, H;
while (scanf("%d%d", &R, &H) != EOF) {
int ans = H / R * 2;
H -= ans * R / 2;
if (H * 2 < R)
ans++;
else {
if ((double)(2 * H) < sqrt(3.0) * (double)R)
ans += 2;
else
ans += 3;
}
printf("%d\n", ans);
}
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
You are given a rooted tree. Each vertex contains a_i tons of gold, which costs c_i per one ton. Initially, the tree consists only a root numbered 0 with a_0 tons of gold and price c_0 per ton.
There are q queries. Each query has one of two types:
1. Add vertex i (where i is an index of query) as a son to some vertex p_i; vertex i will have a_i tons of gold with c_i per ton. It's guaranteed that c_i > c_{p_i}.
2. For a given vertex v_i consider the simple path from v_i to the root. We need to purchase w_i tons of gold from vertices on this path, spending the minimum amount of money. If there isn't enough gold on the path, we buy all we can.
If we buy x tons of gold in some vertex v the remaining amount of gold in it decreases by x (of course, we can't buy more gold that vertex has at the moment). For each query of the second type, calculate the resulting amount of gold we bought and the amount of money we should spend.
Note that you should solve the problem in online mode. It means that you can't read the whole input at once. You can read each query only after writing the answer for the last query, so don't forget to flush output after printing answers. You can use functions like fflush(stdout) in C++ and BufferedWriter.flush in Java or similar after each writing in your program. In standard (if you don't tweak I/O), endl flushes cout in C++ and System.out.println in Java (or println in Kotlin) makes automatic flush as well.
Input
The first line contains three integers q, a_0 and c_0 (1 ≤ q ≤ 3 ⋅ 10^5; 1 ≤ a_0, c_0 < 10^6) — the number of queries, the amount of gold in the root and its price.
Next q lines contain descriptions of queries; The i-th query has one of two types:
* "1 p_i a_i c_i" (0 ≤ p_i < i; 1 ≤ a_i, c_i < 10^6): add vertex i as a son to vertex p_i. The vertex i will have a_i tons of gold with price c_i per one ton. It's guaranteed that p_i exists and c_i > c_{p_i}.
* "2 v_i w_i" (0 ≤ v_i < i; 1 ≤ w_i < 10^6): buy w_i tons of gold from vertices on path from v_i to 0 spending the minimum amount of money. If there isn't enough gold, we buy as much as we can. It's guaranteed that vertex v_i exist.
It's guaranteed that there is at least one query of the second type.
Output
For each query of the second type, print the resulting amount of gold we bought and the minimum amount of money we should spend.
Example
Input
5 5 2
2 0 2
1 0 3 4
2 2 4
1 0 1 3
2 4 2
Output
2 4
4 10
1 3
Note
Explanation of the sample:
At the first query, the tree consist of root, so we purchase 2 tons of gold and pay 2 ⋅ 2 = 4. 3 tons remain in the root.
At the second query, we add vertex 2 as a son of vertex 0. Vertex 2 now has 3 tons of gold with price 4 per one ton.
At the third query, a path from 2 to 0 consists of only vertices 0 and 2 and since c_0 < c_2 we buy 3 remaining tons of gold in vertex 0 and 1 ton in vertex 2. So we bought 3 + 1 = 4 tons and paid 3 ⋅ 2 + 1 ⋅ 4 = 10. Now, in vertex 0 no gold left and 2 tons of gold remain in vertex 2.
At the fourth query, we add vertex 4 as a son of vertex 0. Vertex 4 now has 1 ton of gold with price 3.
At the fifth query, a path from 4 to 0 consists of only vertices 0 and 4. But since no gold left in vertex 0 and only 1 ton is in vertex 4, we buy 1 ton of gold in vertex 4 and spend 1 ⋅ 3 = 3. Now, in vertex 4 no gold left.
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
const int N=300005;
int n,a[N],c[N],fa[N][19],d[N];
int main()
{
scanf("%d%d%d",&n,&a[0],&c[0]);
for(int x=1;x<=n;x++)
{
int t;
scanf("%d",&t);
if(t==1)
{
scanf("%d%d%d",&fa[x][0],&a[x],&c[x]);
d[x]=d[fa[x][0]]+1;
for(int j=1;j<=18;j++)
fa[x][j]=fa[fa[x][j-1]][j-1];
}
else
{
int v,w;
scanf("%d%d",&v,&w);
int s1=0;
long long s2=0;
while(s1!=w&&a[v])
{
int u=v;
for(int j=18;j>=0;j--)
if(d[u]>=(1<<j)&&a[fa[u][j]])
u=fa[u][j];
int k=min(w-s1,a[u]);
a[u]-=k;
s1+=k;
s2+=1ll*k*c[u];
}
printf("%d %lld\n",s1,s2);
}
fflush(stdout);
}
return 0;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
Bob wants to put a new bargaining table in his office. To do so he measured the office room thoroughly and drew its plan: Bob's office room is a rectangular room n × m meters. Each square meter of the room is either occupied by some furniture, or free. A bargaining table is rectangular, and should be placed so, that its sides are parallel to the office walls. Bob doesn't want to change or rearrange anything, that's why all the squares that will be occupied by the table should be initially free. Bob wants the new table to sit as many people as possible, thus its perimeter should be maximal. Help Bob find out the maximum possible perimeter of a bargaining table for his office.
Input
The first line contains 2 space-separated numbers n and m (1 ≤ n, m ≤ 25) — the office room dimensions. Then there follow n lines with m characters 0 or 1 each. 0 stands for a free square meter of the office room. 1 stands for an occupied square meter. It's guaranteed that at least one square meter in the room is free.
Output
Output one number — the maximum possible perimeter of a bargaining table for Bob's office room.
Examples
Input
3 3
000
010
000
Output
8
Input
5 4
1100
0000
0000
0000
0000
Output
16
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t, n, m, a, b, c, q, k, d, x;
cin >> n >> m;
vector<vector<int>> mat(n + 1, vector<int>(m + 1)),
ans(n + 1, vector<int>(m + 1));
char ch;
for (int i = 1; i < n + 1; i++) {
for (int j = 1; j < m + 1; j++) {
cin >> ch;
mat[i][j] = ch - '0';
ans[i][j] = ans[i - 1][j] + ans[i][j - 1] - ans[i - 1][j - 1] + mat[i][j];
}
}
a = 0;
for (int i = 1; i < n + 1; i++) {
for (int j = 1; j < m + 1; j++) {
for (int i_ = i; i_ < n + 1; i_++) {
for (int j_ = j; j_ < m + 1; j_++) {
if (ans[i_][j_] - ans[i - 1][j_] - ans[i_][j - 1] +
ans[i - 1][j - 1] ==
0) {
a = max(a, 2 * (i_ - i + 1 + j_ - j + 1));
}
}
}
}
}
cout << a << "\n";
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
'In Boolean logic, a formula is in conjunctive normal form (CNF) or clausal normal form if it is a conjunction of clauses, where a clause is a disjunction of literals' (cited from https://en.wikipedia.org/wiki/Conjunctive_normal_form)
In the other words, CNF is a formula of type <image>, where & represents a logical "AND" (conjunction), <image> represents a logical "OR" (disjunction), and vij are some boolean variables or their negations. Each statement in brackets is called a clause, and vij are called literals.
You are given a CNF containing variables x1, ..., xm and their negations. We know that each variable occurs in at most two clauses (with negation and without negation in total). Your task is to determine whether this CNF is satisfiable, that is, whether there are such values of variables where the CNF value is true. If CNF is satisfiable, then you also need to determine the values of the variables at which the CNF is true.
It is guaranteed that each variable occurs at most once in each clause.
Input
The first line contains integers n and m (1 ≤ n, m ≤ 2·105) — the number of clauses and the number variables, correspondingly.
Next n lines contain the descriptions of each clause. The i-th line first contains first number ki (ki ≥ 1) — the number of literals in the i-th clauses. Then follow space-separated literals vij (1 ≤ |vij| ≤ m). A literal that corresponds to vij is x|vij| either with negation, if vij is negative, or without negation otherwise.
Output
If CNF is not satisfiable, print a single line "NO" (without the quotes), otherwise print two strings: string "YES" (without the quotes), and then a string of m numbers zero or one — the values of variables in satisfying assignment in the order from x1 to xm.
Examples
Input
2 2
2 1 -2
2 2 -1
Output
YES
11
Input
4 3
1 1
1 2
3 -1 -2 3
1 -3
Output
NO
Input
5 6
2 1 2
3 1 -2 3
4 -3 5 4 6
2 -6 -4
1 5
Output
YES
100010
Note
In the first sample test formula is <image>. One of possible answer is x1 = TRUE, x2 = TRUE.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
vector<int> adj[maxn][2];
vector<int> G[maxn], id[maxn];
char ans[maxn];
bool ok[maxn];
int n, m;
queue<int> q;
void bfs() {
while (q.size()) {
int u = q.front();
q.pop();
for (int i = 0, M = G[u].size(); i < M; i++) {
int v = G[u][i];
if (ok[v]) continue;
ok[v] = true;
q.push(v);
int var = id[u][i];
ans[var] = (v == adj[var][1][0]) + '0';
}
}
}
bool vis[maxn];
bool dfs(int u, int pvar) {
if (vis[u]) return true;
vis[u] = true;
for (int i = 0, M = G[u].size(); i < M; i++) {
int v = G[u][i];
int var = id[u][i];
if (var == pvar) continue;
if (dfs(v, var)) {
ok[u] = true;
q.push(u);
ans[var] = (u == adj[var][1][0]) + '0';
return true;
}
}
return false;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
int k;
scanf("%d", &k);
int v;
while (k--) {
scanf("%d", &v);
int fg = v;
if (v < 0) v = -v;
adj[--v][fg > 0].push_back(i);
}
}
for (int i = 0; i < m; i++) {
if (adj[i][0].empty()) {
for (int j = 0, M = adj[i][1].size(); j < M; j++) {
ok[adj[i][1][j]] = true;
q.push(adj[i][1][j]);
}
ans[i] = '1';
} else if (adj[i][1].empty()) {
for (int j = 0, M = adj[i][0].size(); j < M; j++) {
ok[adj[i][0][j]] = true;
q.push(adj[i][0][j]);
}
ans[i] = '0';
} else {
int u = adj[i][0][0], v = adj[i][1][0];
G[u].push_back(v);
id[u].push_back(i);
G[v].push_back(u);
id[v].push_back(i);
}
}
for (int i = 0; i < n; i++) {
bfs();
if (ok[i]) continue;
if (!dfs(i, -1)) {
puts("NO");
return 0;
}
}
puts("YES");
for (int i = 0; i < m; i++) {
if (ans[i])
putchar(ans[i]);
else
putchar('0');
}
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
There are b boys and g girls participating in Olympiad of Metropolises. There will be a board games tournament in the evening and n participants have accepted the invitation. The organizers do not know how many boys and girls are among them.
Organizers are preparing red badges for girls and blue ones for boys.
Vasya prepared n+1 decks of badges. The i-th (where i is from 0 to n, inclusive) deck contains i blue badges and n-i red ones. The total number of badges in any deck is exactly n.
Determine the minimum number of decks among these n+1 that Vasya should take, so that there will be a suitable deck no matter how many girls and boys there will be among the participants of the tournament.
Input
The first line contains an integer b (1 ≤ b ≤ 300), the number of boys.
The second line contains an integer g (1 ≤ g ≤ 300), the number of girls.
The third line contains an integer n (1 ≤ n ≤ b + g), the number of the board games tournament participants.
Output
Output the only integer, the minimum number of badge decks that Vasya could take.
Examples
Input
5
6
3
Output
4
Input
5
3
5
Output
4
Note
In the first example, each of 4 decks should be taken: (0 blue, 3 red), (1 blue, 2 red), (2 blue, 1 red), (3 blue, 0 red).
In the second example, 4 decks should be taken: (2 blue, 3 red), (3 blue, 2 red), (4 blue, 1 red), (5 blue, 0 red). Piles (0 blue, 5 red) and (1 blue, 4 red) can not be used.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
const long long INF = 1e18;
const int MAXN = 1e5 + 1;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int b, g, n;
cin >> b >> g >> n;
cout << (n == g + b ? 1 : min(b, min(g, n)) + 1 - max(0, n - max(b, g)));
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
Note that the memory limit is unusual.
You are given an integer n and two sequences a_1, a_2, ..., a_n and b_1, b_2, ..., b_n.
Let's call a set of integers S such that S ⊆ \{1, 2, 3, ..., n\} strange, if, for every element i of S, the following condition is met: for every j ∈ [1, i - 1], if a_j divides a_i, then j is also included in S. An empty set is always strange.
The cost of the set S is ∑_{i ∈ S} b_i. You have to calculate the maximum possible cost of a strange set.
Input
The first line contains one integer n (1 ≤ n ≤ 3000).
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 100).
The third line contains n integers b_1, b_2, ..., b_n (-10^5 ≤ b_i ≤ 10^5).
Output
Print one integer — the maximum cost of a strange set.
Examples
Input
9
4 7 3 4 5 6 7 8 13
-2 3 -19 5 -6 7 -8 9 1
Output
16
Input
2
42 42
-37 13
Output
0
Input
2
42 42
13 -37
Output
13
Note
The strange set with the maximum cost in the first example is \{1, 2, 4, 8, 9\}.
The strange set with the maximum cost in the second example is empty.
### Response
```cpp
#include<iostream>
#include<cstdio>
#include<queue>
#include<cstring>
using namespace std;
typedef long long ll;
#define d(x) cerr << #x << " = " << x << endl
const int maxn = 3005;
const int maxm = 1000005;
const int inf = 0x3f3f3f3f;
int n;
int a[maxn], b[maxn];
int dis[maxn], cur[maxn], vis[maxn];
int head[maxn], nxt[maxm << 1], tail[maxm << 1], cap[maxm << 1], ecnt = 1;
void addedge(int u, int v, int c) {
nxt[++ecnt] = head[u];
head[u] = ecnt;
tail[ecnt] = v;
cap[ecnt] = c;
}
int bfs(int S, int T) {
memset(dis, 0, sizeof(dis));
queue<int> que; que.push(S); dis[S] = 1;
while (!que.empty()) {
int u = que.front(); que.pop();
for (int e = head[u]; e; e = nxt[e]) {
int v = tail[e];
if (cap[e] && !dis[v]) {
dis[v] = dis[u] + 1;
que.push(v);
}
}
}
return (dis[T] > 0);
}
int dfs(int u, int T, int flowin) {
if (u == T || !flowin) return flowin;
int maxflow = 0;
for (int &e = cur[u]; e; e = nxt[e]) {
int v = tail[e];
if (cap[e] && dis[v] == dis[u] + 1) {
int tmp = dfs(v, T, min(flowin, cap[e]));
maxflow += tmp; flowin -= tmp;
cap[e] -= tmp; cap[e ^ 1] += tmp;
if (!flowin) break;
}
}
if (!maxflow) dis[u] = 0;
return maxflow;
}
int dinic(int S, int T) {
int ret = 0;
while (bfs(S, T)) {
memcpy(cur, head, sizeof(head));
ret += dfs(S, T, inf);
}
return ret;
}
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]);
int S = n + 1, T = n + 2, sum = 0;
for (int i = 1; i <= n; i++) {
if (b[i] >= 0) {
addedge(S, i, b[i]); addedge(i, S, 0);
sum += b[i];
} else {
addedge(i, T, -b[i]); addedge(T, i, 0);
}
}
for (int i = 1; i <= n; i++) {
memset(vis, 0, sizeof(vis));
for (int j = i - 1; j >= 1; j--) {
if (a[i] % a[j] != 0) continue;
if (!vis[a[j]]) {
addedge(i, j, inf); addedge(j, i, 0);
for (int p = 1; p * p <= a[j]; p++) {
if (a[j] % p != 0) continue;
int p1 = p, p2 = a[j] / p;
vis[p1] = vis[p2] = 1;
}
}
}
}
printf("%d\n", sum - dinic(S, T));
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
M-kun is a student in Aoki High School, where a year is divided into N terms.
There is an exam at the end of each term. According to the scores in those exams, a student is given a grade for each term, as follows:
* For the first through (K-1)-th terms: not given.
* For each of the K-th through N-th terms: the multiplication of the scores in the last K exams, including the exam in the graded term.
M-kun scored A_i in the exam at the end of the i-th term.
For each i such that K+1 \leq i \leq N, determine whether his grade for the i-th term is strictly greater than the grade for the (i-1)-th term.
Constraints
* 2 \leq N \leq 200000
* 1 \leq K \leq N-1
* 1 \leq A_i \leq 10^{9}
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N K
A_1 A_2 A_3 \ldots A_N
Output
Print the answer in N-K lines.
The i-th line should contain `Yes` if the grade for the (K+i)-th term is greater than the grade for the (K+i-1)-th term, and `No` otherwise.
Examples
Input
5 3
96 98 95 100 20
Output
Yes
No
Input
3 2
1001 869120 1001
Output
No
Input
15 7
3 1 4 1 5 9 2 6 5 3 5 8 9 7 9
Output
Yes
Yes
No
Yes
Yes
No
Yes
Yes
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(){
int n, k;
cin >> n >> k;
vector<int> a(n);
for(int i=0;i<n;i++) cin >> a[i];
for(int i=0;i<n-k;i++){
cout << (a[i] < a[i+k] ? "Yes" : "No") << endl;
}
return 0;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
The sequence is called ordered if it is non-decreasing or non-increasing. For example, sequnces [3, 1, 1, 0] and [1, 2, 3, 100] are ordered, but the sequence [1, 3, 3, 1] is not. You are given a sequence of numbers. You are to find it's shortest subsequence which is not ordered.
A subsequence is a sequence that can be derived from the given sequence by deleting zero or more elements without changing the order of the remaining elements.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 105). The second line contains n space-separated integers — the given sequence. All numbers in this sequence do not exceed 106 by absolute value.
Output
If the given sequence does not contain any unordered subsequences, output 0. Otherwise, output the length k of the shortest such subsequence. Then output k integers from the range [1..n] — indexes of the elements of this subsequence. If there are several solutions, output any of them.
Examples
Input
5
67 499 600 42 23
Output
3
1 3 5
Input
3
1 2 3
Output
0
Input
3
2 3 1
Output
3
1 2 3
### Response
```cpp
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:268435456")
using namespace std;
template <typename T>
inline T abs(T a) {
return ((a < 0) ? -a : a);
}
template <typename T>
inline T sqr(T a) {
return a * a;
}
template <class T>
T gcd(T a, T b) {
return a ? gcd(b % a, a) : b;
}
template <class T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
template <class T>
T sign(T a) {
return a > 0 ? 1 : (a < 0 ? -1 : 0);
}
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, 1, 0, -1};
const int dxK[] = {-1, -1, 0, 1, 1, 1, 0, -1};
const int dyK[] = {0, 1, 1, 1, 0, -1, -1, -1};
const int dxKn[] = {-2, -1, 1, 2, 2, 1, -1, -2};
const int dyKn[] = {1, 2, 2, 1, -1, -2, -2, -1};
const int N = int(1e5) + 9;
const int M = int(3e3) + 9;
const int LOGN = 22;
const int SQN = 350;
const int MOD = int(1e9) + 7;
const int INF = 1e9 + 100;
const long long INF64 = 2e18;
const long double PI = 3.1415926535897932384626433832795;
const long double EPS = 1e-9;
int a[N];
int mxl[N], idmxl[N];
int mxr[N], idmxr[N];
int mnl[N], idmnl[N];
int mnr[N], idmnr[N];
void solve() {
int n;
cin >> n;
for (int i = 0; i < (int)(n); ++i) cin >> a[i];
for (int i = 0; i < (int)(n); ++i) {
mnl[i] = a[i];
idmnl[i] = i;
mxl[i] = a[i];
idmxl[i] = i;
if (i > 0 && mnl[i - 1] < mnl[i]) {
mnl[i] = mnl[i - 1];
idmnl[i] = idmnl[i - 1];
}
if (i > 0 && mxl[i - 1] > mxl[i]) {
mxl[i] = mxl[i - 1];
idmxl[i] = idmxl[i - 1];
}
}
for (int i = int(n) - 1; i >= 0; --i) {
mxr[i] = a[i];
idmxr[i] = i;
mnr[i] = a[i];
idmnr[i] = i;
if (i < n - 1 && mxr[i + 1] > mxr[i]) {
mxr[i] = mxr[i + 1];
idmxr[i] = idmxr[i + 1];
}
if (i < n - 1 && mnr[i + 1] > mnr[i]) {
mnr[i] = mnr[i + 1];
idmnr[i] = idmnr[i + 1];
}
}
for (int i = 1; i < (int)(n - 1); ++i) {
if (a[i] > mnl[i - 1] && a[i] > mnr[i + 1]) {
puts("3");
cout << idmnl[i - 1] + 1 << ' ' << i + 1 << ' ' << idmnr[i + 1] + 1
<< endl;
return;
}
}
for (int i = 1; i < (int)(n - 1); ++i) {
if (a[i] < mxl[i - 1] && a[i] < mxr[i + 1]) {
puts("3");
cout << idmxl[i - 1] + 1 << ' ' << i + 1 << ' ' << idmxr[i + 1] + 1
<< endl;
return;
}
}
cout << 0;
}
int main() {
srand(time(NULL));
cout << setprecision(10) << fixed;
cerr << setprecision(10) << fixed;
solve();
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
Three-valued logic is a logic system that has, in addition to "true" and "false", "unknown" as a valid value. In the following, logical values "false", "unknown" and "true" are represented by 0, 1 and 2 respectively.
Let "-" be a unary operator (i.e. a symbol representing one argument function) and let both "*" and "+" be binary operators (i.e. symbols representing two argument functions). These operators represent negation (NOT), conjunction (AND) and disjunction (OR) respectively. These operators in three-valued logic can be defined in Table C-1.
Table C-1: Truth tables of three-valued logic operators
-X| | (X*Y)| | (X+Y) | <image>| | <image>| | <image> |
---|---|---|---|---|---
Let P, Q and R be variables ranging over three-valued logic values. For a given formula, you are asked to answer the number of triples (P,Q,R) that satisfy the formula, that is, those which make the value of the given formula 2. A formula is one of the following form (X and Y represent formulas).
* Constants: 0, 1 or 2
* Variables: P, Q or R
* Negations: -X
* Conjunctions: (X*Y)
* Disjunctions: (X+Y)
Note that conjunctions and disjunctions of two formulas are always parenthesized.
For example, when formula (P*Q) is given as an input, the value of this formula is 2 when and only when (P,Q,R) is (2,2,0), (2,2,1) or (2,2,2). Therefore, you should output 3.
Input
The input consists of one or more lines. Each line contains a formula. A formula is a string which consists of 0, 1, 2, P, Q, R, -, *, +, (, ). Other characters such as spaces are not contained. The grammar of formulas is given by the following BNF.
<formula> ::= 0 | 1 | 2 | P | Q | R |
-<formula> | (<formula>*<formula>) | (<formula>+<formula>)
All the formulas obey this syntax and thus you do not have to care about grammatical errors. Input lines never exceed 80 characters.
Finally, a line which contains only a "." (period) comes, indicating the end of the input.
Output
You should answer the number (in decimal) of triples (P,Q,R) that make the value of the given formula 2. One line containing the number should be output for each of the formulas, and no other characters should be output.
Sample Input
(P*Q)
(--R+(P*Q))
(P*-P)
2
1
(-1+(((---P+Q)*(--Q+---R))*(-R+-P)))
.
Output for the Sample Input
3
11
0
27
0
7
Example
Input
(P*Q)
(--R+(P*Q))
(P*-P)
2
1
(-1+(((---P+Q)*(--Q+---R))*(-R+-P)))
.
Output
3
11
0
27
0
7
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int calc_neg(int a) { return 2 - a; }
int calc_plus(int a, int b) { return max(a, b); }
int calc_mult(int a, int b) { return min(a, b); }
int calc_op(int l, int r, char op) {
if(op == '+') return calc_plus(l, r);
if(op == '*') return calc_mult(l, r);
assert(false);
}
int parse(const string &s, int &idx, map<char, int> mp) {
if(s[idx] == '-') {
idx++;
return calc_neg(parse(s, idx, mp));
} else if(s[idx] == '(') {
idx++;
int left = parse(s, idx, mp);
char op = s[idx];
idx++;
int right = parse(s, idx, mp);
assert(s[idx] == ')');
idx++;
return calc_op(left, right, op);
} else if('0' <= s[idx] && s[idx] <= '2') {
int n = s[idx] - '0';
idx++;
return n;
} else {
int n = mp[s[idx]];
idx++;
return n;
}
}
bool solve() {
string s;
cin >> s;
if(s == ".") return false;
map<char, int> mp;
int ans = 0;
for(int i = 0; i < 3 * 3 * 3; i++) {
int cpy = i;
for(int j = 0; j < 3; j++) {
mp['P' + j] = cpy % 3;
cpy /= 3;
}
int idx = 0;
int res = parse(s, idx, mp);
ans += res == 2;
}
cout << ans << endl;
return true;
}
int main() {
while(solve());
return 0;
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
In one of the games Arkady is fond of the game process happens on a rectangular field. In the game process Arkady can buy extensions for his field, each extension enlarges one of the field sizes in a particular number of times. Formally, there are n extensions, the i-th of them multiplies the width or the length (by Arkady's choice) by ai. Each extension can't be used more than once, the extensions can be used in any order.
Now Arkady's field has size h × w. He wants to enlarge it so that it is possible to place a rectangle of size a × b on it (along the width or along the length, with sides parallel to the field sides). Find the minimum number of extensions needed to reach Arkady's goal.
Input
The first line contains five integers a, b, h, w and n (1 ≤ a, b, h, w, n ≤ 100 000) — the sizes of the rectangle needed to be placed, the initial sizes of the field and the number of available extensions.
The second line contains n integers a1, a2, ..., an (2 ≤ ai ≤ 100 000), where ai equals the integer a side multiplies by when the i-th extension is applied.
Output
Print the minimum number of extensions needed to reach Arkady's goal. If it is not possible to place the rectangle on the field with all extensions, print -1. If the rectangle can be placed on the initial field, print 0.
Examples
Input
3 3 2 4 4
2 5 4 10
Output
1
Input
3 3 3 3 5
2 3 5 4 2
Output
0
Input
5 5 1 2 3
2 2 3
Output
-1
Input
3 4 1 1 3
2 3 2
Output
3
Note
In the first example it is enough to use any of the extensions available. For example, we can enlarge h in 5 times using the second extension. Then h becomes equal 10 and it is now possible to place the rectangle on the field.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5L + 11, M = 1e3L + 11;
int c[N];
int p[M], q[M];
int ip[N], iq[N];
int dp[2][M][M];
void upd(int &a, int b) {
if (!~a || a > b) a = b;
}
int main() {
ios ::sync_with_stdio(0);
int a, b, ih, iw, n;
cin >> ih >> iw >> a >> b >> n;
for (int i = 0; i < n; i++) cin >> c[i];
sort(c, c + n, greater<int>());
int ans = -1;
for (int _ = 0; _ < 2; _++) {
int h = (ih + a - 1) / a;
int w = (iw + b - 1) / b;
int ch = 0;
for (int i = h; i >= 1; i--)
if (i == h || (h + i - 1) / i != p[ch]) {
p[++ch] = (h + i - 1) / i;
ip[(h + i - 1) / i] = ch;
}
int cw = 0;
for (int i = w; i >= 1; i--)
if (i == w || (w + i - 1) / i != q[cw]) {
q[++cw] = (w + i - 1) / i;
iq[(w + i - 1) / i] = cw;
}
memset(dp, -1, sizeof dp);
dp[0][ip[h]][iq[w]] = 0;
int now = 0;
for (int i = 0; i < min(n, 40); i++) {
int nxt = now ^ 1;
memset(dp[nxt], -1, sizeof dp[nxt]);
for (int j = 1; j <= ch; j++)
for (int k = 1; k <= cw; k++)
if (~dp[now][j][k]) {
upd(dp[nxt][ip[(p[j] + c[i] - 1) / c[i]]][k], dp[now][j][k] + 1);
upd(dp[nxt][j][iq[(q[k] + c[i] - 1) / c[i]]], dp[now][j][k] + 1);
upd(dp[nxt][j][k], dp[now][j][k]);
}
now = nxt;
}
upd(ans, dp[now][1][1]);
swap(ih, iw);
}
cout << ans << '\n';
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
In order to celebrate Twice's 5th anniversary, Tzuyu and Sana decided to play a game.
Tzuyu gave Sana two integers a and b and a really important quest.
In order to complete the quest, Sana has to output the smallest possible value of (a ⊕ x) + (b ⊕ x) for any given x, where ⊕ denotes the [bitwise XOR operation](http://en.wikipedia.org/wiki/Bitwise_operation#XOR).
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^{4}). Description of the test cases follows.
The only line of each test case contains two integers a and b (1 ≤ a, b ≤ 10^{9}).
Output
For each testcase, output the smallest possible value of the given expression.
Example
Input
6
6 12
4 9
59 832
28 14
4925 2912
1 1
Output
10
13
891
18
6237
0
Note
For the first test case Sana can choose x=4 and the value will be (6 ⊕ 4) + (12 ⊕ 4) = 2 + 8 = 10. It can be shown that this is the smallest possible value.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int a, b;
cin >> a >> b;
cout << (a ^ b) << '\n';
}
return 0;
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
Professor GukiZ was playing with arrays again and accidentally discovered new function, which he called GukiZiana. For given array a, indexed with integers from 1 to n, and number y, GukiZiana(a, y) represents maximum value of j - i, such that aj = ai = y. If there is no y as an element in a, then GukiZiana(a, y) is equal to - 1. GukiZ also prepared a problem for you. This time, you have two types of queries:
1. First type has form 1 l r x and asks you to increase values of all ai such that l ≤ i ≤ r by the non-negative integer x.
2. Second type has form 2 y and asks you to find value of GukiZiana(a, y).
For each query of type 2, print the answer and make GukiZ happy!
Input
The first line contains two integers n, q (1 ≤ n ≤ 5 * 105, 1 ≤ q ≤ 5 * 104), size of array a, and the number of queries.
The second line contains n integers a1, a2, ... an (1 ≤ ai ≤ 109), forming an array a.
Each of next q lines contain either four or two numbers, as described in statement:
If line starts with 1, then the query looks like 1 l r x (1 ≤ l ≤ r ≤ n, 0 ≤ x ≤ 109), first type query.
If line starts with 2, then th query looks like 2 y (1 ≤ y ≤ 109), second type query.
Output
For each query of type 2, print the value of GukiZiana(a, y), for y value for that query.
Examples
Input
4 3
1 2 3 4
1 1 2 1
1 1 1 1
2 3
Output
2
Input
2 3
1 2
1 2 2 1
2 3
2 4
Output
0
-1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct w {
int i;
long long v;
} wt;
bool operator<(const w& a, const w& b) {
if (a.v != b.v) return a.v < b.v;
return a.i < b.i;
}
int n, q;
int per;
vector<vector<w> > ww;
vector<w>::iterator it;
vector<long long> dx;
int ta, tb, tc, td, te;
int main() {
scanf("%d", &n);
scanf("%d", &q);
per = (int)sqrt(n);
for (int a = 0; a < n; a++) {
scanf("%d", &ta);
if (a % per == 0) {
ww.push_back(vector<w>());
dx.push_back(0);
}
ww.back().push_back((w){a, ta});
}
for (int a = 0; a < ww.size(); a++) sort(ww[a].begin(), ww[a].end());
while (q-- > 0) {
scanf("%d", &ta);
if (ta == 1) {
scanf("%d", &ta);
scanf("%d", &tb);
scanf("%d", &tc);
ta--;
tb--;
td = ta / per;
te = tb / per;
if (td == te) {
for (int a = 0; a < ww[td].size(); a++)
if (ww[td][a].i >= ta && ww[td][a].i <= tb) ww[td][a].v += tc;
sort(ww[td].begin(), ww[td].end());
} else {
for (int a = 0; a < ww[td].size(); a++)
if (ww[td][a].i >= ta) ww[td][a].v += tc;
sort(ww[td].begin(), ww[td].end());
for (int a = td + 1; a < te; a++) dx[a] += tc;
for (int a = 0; a < ww[te].size(); a++)
if (ww[te][a].i <= tb) ww[te][a].v += tc;
sort(ww[te].begin(), ww[te].end());
}
} else {
scanf("%d", &ta);
tb = tc = -1;
for (int a = 0; a < ww.size(); a++) {
wt = (w){-1, ta - dx[a]};
it = lower_bound(ww[a].begin(), ww[a].end(), wt);
if (it != ww[a].end() && (*it).v == wt.v) {
tb = (*it).i;
break;
}
}
if (tb == -1) {
printf("-1\n");
continue;
}
for (int a = ww.size() - 1; a >= 0; a--) {
wt = (w){INT_MAX, ta - dx[a]};
it = upper_bound(ww[a].begin(), ww[a].end(), wt);
if (it != ww[a].begin()) {
it--;
if ((*it).v == wt.v) {
tc = (*it).i;
break;
}
}
}
printf("%d\n", tc - tb);
}
}
return 0;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
On vacations n pupils decided to go on excursion and gather all together. They need to overcome the path with the length l meters. Each of the pupils will go with the speed equal to v1. To get to the excursion quickly, it was decided to rent a bus, which has seats for k people (it means that it can't fit more than k people at the same time) and the speed equal to v2. In order to avoid seasick, each of the pupils want to get into the bus no more than once.
Determine the minimum time required for all n pupils to reach the place of excursion. Consider that the embarkation and disembarkation of passengers, as well as the reversal of the bus, take place immediately and this time can be neglected.
Input
The first line of the input contains five positive integers n, l, v1, v2 and k (1 ≤ n ≤ 10 000, 1 ≤ l ≤ 109, 1 ≤ v1 < v2 ≤ 109, 1 ≤ k ≤ n) — the number of pupils, the distance from meeting to the place of excursion, the speed of each pupil, the speed of bus and the number of seats in the bus.
Output
Print the real number — the minimum time in which all pupils can reach the place of excursion. Your answer will be considered correct if its absolute or relative error won't exceed 10 - 6.
Examples
Input
5 10 1 2 5
Output
5.0000000000
Input
3 6 1 2 1
Output
4.7142857143
Note
In the first sample we should immediately put all five pupils to the bus. The speed of the bus equals 2 and the distance is equal to 10, so the pupils will reach the place of excursion in time 10 / 2 = 5.
### Response
```cpp
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("Ofast")
using namespace std;
long long int n, l, v1, v2, k;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> n >> l >> v1 >> v2 >> k;
if (n == k) {
cout << fixed << setprecision(8)
<< (long double)((long double)l / (long double)v2) << '\n';
return 0;
}
long long int x = (n + k - 1) / k;
long double a, b;
a = v1;
b = v2;
long double t = 1;
for (long long int i = 0; i < x - 1; i++) {
long double res = (b - a) * v1 / (v1 + v2);
long double d = res / v1;
t += d;
a += d * v1;
b += d * v1;
d = (b - a) / (long double)(v2 - v1);
t += d;
a += d * v1;
b += d * v1;
}
cout << fixed << setprecision(8) << t * (long double)(l / b) << '\n';
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
Okabe needs bananas for one of his experiments for some strange reason. So he decides to go to the forest and cut banana trees.
Consider the point (x, y) in the 2D plane such that x and y are integers and 0 ≤ x, y. There is a tree in such a point, and it has x + y bananas. There are no trees nor bananas in other points. Now, Okabe draws a line with equation <image>. Okabe can select a single rectangle with axis aligned sides with all points on or under the line and cut all the trees in all points that are inside or on the border of this rectangle and take their bananas. Okabe's rectangle can be degenerate; that is, it can be a line segment or even a point.
Help Okabe and find the maximum number of bananas he can get if he chooses the rectangle wisely.
Okabe is sure that the answer does not exceed 1018. You can trust him.
Input
The first line of input contains two space-separated integers m and b (1 ≤ m ≤ 1000, 1 ≤ b ≤ 10000).
Output
Print the maximum number of bananas Okabe can get from the trees he cuts.
Examples
Input
1 5
Output
30
Input
2 3
Output
25
Note
<image>
The graph above corresponds to sample test 1. The optimal rectangle is shown in red and has 30 bananas.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const int mod = 1000 * 1000 * 1000 + 7;
const long long inf = 1e18;
int cl(int a, int b) {
if (a % b == 0)
return a / b;
else
return a / b + 1;
}
long long cl(long long a, long long b) {
if (a % b == 0)
return a / b;
else
return a / b + 1;
}
long long a, c, b, d, e, f, g, h, i, j, k, l, m, n, p, q, r, t, u, w, x, y, z,
ara[100005], arr[100005], ans = 0;
string s, s2, s3;
vector<long long> v, v2, v3;
int main() {
cin >> m >> b;
r = b * m, c = b;
for (int i = 0; i <= b; i++) {
x = m * (b - i);
y = i;
ans = max(((y + 1) * ((x * (x + 1)) / 2)) + ((x + 1) * ((y * (y + 1)) / 2)),
ans);
}
cout << ans;
return 0;
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
Now, a ninja is planning to sneak into the castle tower from outside the castle. This ninja can easily run on the ground and swim in the moat, but he is not very good at climbing up from the moat, so he wants to enter the moat as few times as possible.
Create a program that takes a sketch of the castle as input and outputs the minimum number of times you have to crawl up from the moat from outside the castle to the castle tower. The sketch of the castle is given as a two-dimensional grid. The symbols drawn on the sketch show the positions of "&" indicating the position of the castle tower and "#" indicating the position of the moat, and "." (Half-width period) at other points. In addition, it is assumed that there is only one castle tower in the castle, and the ninja moves one square at a time in the north, south, east, and west directions when running or swimming, and does not move diagonally.
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:
n m
c1,1 c1,2 ... c1, n
c2,1c2,2 ... c2, n
::
cm, 1cm, 2 ... cm, n
The first line gives the east-west width n and the north-south width m (1 ≤ n, m ≤ 100) of the sketch. The following m lines give the information on the i-th line of the sketch. Each piece of information is a character string of length n consisting of the symbols "&", "#", and ".".
The number of datasets does not exceed 50.
Output
Outputs the minimum number of times (integer) that must be climbed from the moat for each dataset on one line.
Examples
Input
5 5
.###.
#...#
#.&.#
#...#
.###.
18 15
..####....####....
####..####....####
#...............##
.#.############.##
#..#..........#.##
.#.#.########.#.##
#..#.#......#.#.##
.#.#....&...#.#.##
#..#........#.#.##
.#.#.########.#.##
#..#..........#.##
.#.############.##
#...............##
.#################
##################
9 10
#########
........#
#######.#
#.....#.#
#.###.#.#
#.#&#.#.#
#.#...#.#
#.#####.#
#.......#
#########
9 3
###...###
#.#.&.#.#
###...###
0 0
Output
1
2
0
0
Input
5 5
.###.
...#
.&.#
...#
.###.
18 15
..####....####....
..####....####
...............##
.#.############.##
..#..........#.##
.#.#.########.#.##
..#.#......#.#.##
.#.#....&...#.#.##
..#........#.#.##
.#.#.########.#.##
..#..........#.##
.#.############.##
...............##
.#################
9 10
........#
.#
.....#.#
.###.#.#
.#&#.#.#
.#...#.#
.#####.#
.......#
9 3
...###
.#.&.#.#
...###
0 0
</pre>
Output
1
2
0
0
### Response
```cpp
#include<iostream>
#include<iomanip>
#include<string>
#include<queue>
#include<algorithm>
#define REP(i,a,n) for(int i=(a);i<(n);++i)
#define INV (-1)
#define N 102
#define INFTY (1<<30)
#define PLANE 2
#define MOAT 1
using namespace std;
int n,m;
int map[N][N];
int M[N][N];
bool inline inRange(int t, int min, int max){
return min <= t && t < max;
}
void dfs(int i, int j, int now){
const int ci[] = {-1,0,1,0};
const int cj[] = {0,1,0,-1};
if( M[i][j] != now )
return ;
for(int k = 0; k < sizeof(ci)/sizeof(*ci); ++k){
int ti = i + ci[k];
int tj = j + cj[k];
if( inRange( ti, 0, m+2 ) && inRange( tj, 0, n+2 ) ){
if( map[i][j] == MOAT && map[ti][tj] == PLANE ){
M[ti][tj] = min( M[ti][tj], now + 1 );
continue;
}
if( M[ti][tj] == now ){
continue;
}
M[ti][tj] = now;
dfs( ti, tj, now );
}
}
return ;
}
void ResetMap(){
REP(i,0,N)REP(j,0,N)
{
map[i][j] = PLANE;
M[i][j] = INFTY;
}
}
void PrintMap(){
REP(i,1,m+1){
REP(j,1,n+1){
cout << setw(3) << M[i][j];
}
cout << endl;
}
cout << endl;
}
bool Completed(int *ans){
REP(i,0,m+2){
if( M[i][0] < INFTY ){
*ans = M[i][0];
return true;
}
if( M[i][n+1] < INFTY ){
*ans = M[i][n+1];
return true;
}
}
REP(j,0,n+2){
if( M[0][j] < INFTY ){
*ans = M[0][j];
return true;
}
if( M[m+1][j] < INFTY ){
*ans = M[m+1][j];
return true;
}
}
return false;
}
int main(){
while(true){
int now = 0;
int ans = 1<<21;
int si;
int sj;
cin>>n>>m;
if( m==0&&n==0 )break;
ResetMap();
REP(i,1,m+1){
string s;
cin>>s;
REP(j,1,n+1){
if( s[j-1] == '&' ){
si = i;
sj = j;
M[si][sj] = 0;
}else if( s[j-1] == '#' ){
map[i][j] = MOAT;
}
}
}
while( true ){
REP(i,1,m+1){
REP(j,1,n+1){
dfs( i, j, now );
}
}
if( Completed(&ans) )
break;
else{
++now;
}
}
cout << ans << endl;
}
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
problem
In one river, there is a slightly dangerous game of jumping from one shore to the other on a stone.
<image>
Now, as shown in Figure 4-1 we consider the stone to be above the squares. The number of rows is n. In Figure 4-1 we have n = 5.
In this game, you start with one shore and make a normal jump or a one-line skip less than m times to the other shore. A normal jump is the shore of the line one line ahead of the current line or Jumping to one of the stones, a one-line skipping jump is to jump to the shore of the line two ahead of the current line or to any of the stones. The line one line ahead of the starting shore is It is assumed that the first line and the second line are the second line, and the n − first line two lines ahead and the nth line one line ahead are the opposite banks.
Now, in order to make this game as safe as possible, I decided to consider the risk of jumping. Each stone has a fixed slipperiness. The risk of jumping from stone to stone Is a normal jump or a one-line skip jump
(Slipperiness of the current stone + Slipperiness of the stone to which it jumps) × (Horizontal movement distance)
However, the lateral movement distance is the difference in the number of columns. Also, the risk of jumping from shore to stone or from stone to shore is 0.
Given n, m, the position and slipperiness of each stone as input, write a program to find the minimum total risk of jumping when reaching the opposite shore. Given input data Is always able to reach the opposite shore, and there are no more than one stone in the same square.
input
The input consists of multiple datasets. Each dataset is given in the following format.
On the first line of the input, two integers n, m are written, separated by a blank. This represents the number of lines and the number of jumps allowed to skip one line. N, m are 2 respectively. ≤ n ≤ 150, 0 ≤ m ≤ (n + 1) / 2.
The following n lines contain information about the stones in each line. The i + 1 line (1 ≤ i ≤ n) is one integer ki (0 ≤ ki ≤ 10) followed by 2 x ki integers are written separated by spaces. These represent the information of the stone on the i-th line counting from the starting shore.
ki represents the number of stones in the row, and for the following 2 × ki integers, the 2 × j -1st (1 ≤ j ≤ ki) integers xi, j are the jth in the row. 2 × jth integer di, j represents the slipperiness of the jth stone in the row. Xi, j, di, j are 1 ≤ xi, j, respectively. Satisfy di, j ≤ 1000.
Of the scoring data, n ≤ 6 is satisfied for 20% of the points, and m = 0 is satisfied for the other 20% of the points.
When both n and m are 0, it indicates the end of input. The number of data sets does not exceed 10.
output
For each dataset, print one integer on one line that represents the minimum total risk of jumps when reaching the opposite shore.
Examples
Input
5 1
2 1 3 2 2
1 3 2
1 1 7
1 2 1
1 4 4
5 0
2 1 3 2 2
1 3 2
1 1 7
1 2 1
1 4 4
0 0
Output
17
40
Input
None
Output
None
### Response
```cpp
#include <iostream>
#include <vector>
#include <queue>
#include <cstdlib>
using namespace std;
const int INF = 1 << 30;
class State
{
public:
int p, y, j, d;
State(int _p, int _y, int _j, int _d)
:p(_p), y(_y), j(_j), d(_d) {}
bool operator < (const State& st) const
{
return this->d > st.d;
}
};
int main()
{
int n, m;
while (cin >> n >> m) {
if ((n|m) == 0)
break;
vector<vector<pair<int, int> > > s(n);
for (int i = 0; i < n; ++i) {
int k;
cin >> k;
for (int j = 0; j < k; ++j) {
int x, d;
cin >> x >> d;
s[i].push_back(make_pair(x, d));
}
}
priority_queue<State> que;
for (int i = 0; i < s[0].size(); ++i)
que.push(State(i, 0, 0, 0));
if (m > 0) {
for (int i = 0; i < s[1].size(); ++i)
que.push(State(i, 1, 1, 0));
}
vector<vector<vector<int> > > dp(n, vector<vector<int> >(10, vector<int>(m+1, INF)));
while (!que.empty()) {
const State st = que.top();
que.pop();
if ((st.y == n-2 && st.j < m) || st.y == n-1) {
cout << st.d << endl;
break;
}
if (dp[st.y][st.p][st.j] < st.d)
continue;
dp[st.y][st.p][st.j] = st.d;
for (int i = 0; i < s[st.y+1].size(); ++i) {
int danger = st.d + (s[st.y][st.p].second + s[st.y+1][i].second) * abs(s[st.y][st.p].first - s[st.y+1][i].first);
if (dp[st.y+1][i][st.j] > danger) {
dp[st.y+1][i][st.j] = danger;
que.push(State(i, st.y+1, st.j, danger));
}
}
if (st.j < m && st.y+2 < n) {
for (int i = 0; i < s[st.y+2].size(); ++i) {
int danger = st.d + (s[st.y][st.p].second + s[st.y+2][i].second) * abs(s[st.y][st.p].first - s[st.y+2][i].first);
if (dp[st.y+2][i][st.j+1] > danger) {
dp[st.y+2][i][st.j+1] = danger;
que.push(State(i, st.y+2, st.j+1, danger));
}
}
}
}
}
return 0;
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
Vasya often uses public transport. The transport in the city is of two types: trolleys and buses. The city has n buses and m trolleys, the buses are numbered by integers from 1 to n, the trolleys are numbered by integers from 1 to m.
Public transport is not free. There are 4 types of tickets:
1. A ticket for one ride on some bus or trolley. It costs c1 burles;
2. A ticket for an unlimited number of rides on some bus or on some trolley. It costs c2 burles;
3. A ticket for an unlimited number of rides on all buses or all trolleys. It costs c3 burles;
4. A ticket for an unlimited number of rides on all buses and trolleys. It costs c4 burles.
Vasya knows for sure the number of rides he is going to make and the transport he is going to use. He asked you for help to find the minimum sum of burles he will have to spend on the tickets.
Input
The first line contains four integers c1, c2, c3, c4 (1 ≤ c1, c2, c3, c4 ≤ 1000) — the costs of the tickets.
The second line contains two integers n and m (1 ≤ n, m ≤ 1000) — the number of buses and trolleys Vasya is going to use.
The third line contains n integers ai (0 ≤ ai ≤ 1000) — the number of times Vasya is going to use the bus number i.
The fourth line contains m integers bi (0 ≤ bi ≤ 1000) — the number of times Vasya is going to use the trolley number i.
Output
Print a single number — the minimum sum of burles Vasya will have to spend on the tickets.
Examples
Input
1 3 7 19
2 3
2 5
4 4 4
Output
12
Input
4 3 2 1
1 3
798
1 2 3
Output
1
Input
100 100 8 100
3 5
7 94 12
100 1 47 0 42
Output
16
Note
In the first sample the profitable strategy is to buy two tickets of the first type (for the first bus), one ticket of the second type (for the second bus) and one ticket of the third type (for all trolleys). It totals to (2·1) + 3 + 7 = 12 burles.
In the second sample the profitable strategy is to buy one ticket of the fourth type.
In the third sample the profitable strategy is to buy two tickets of the third type: for all buses and for all trolleys.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long MAX_I = 1000;
long long a[MAX_I + 1];
long long b[MAX_I + 1];
int main() {
long long n, m;
long long c[5];
long long tmp;
long long asum = 0;
long long bsum = 0;
cin >> c[1] >> c[2] >> c[3] >> c[4];
cin >> n >> m;
for (long long i = 0; i < n; ++i) {
cin >> tmp;
a[i] = min(c[2], c[1] * tmp);
asum += a[i];
}
for (long long i = 0; i < m; ++i) {
cin >> tmp;
b[i] = min(c[2], c[1] * tmp);
bsum += b[i];
}
asum = min(asum, c[3]);
bsum = min(bsum, c[3]);
cout << min(asum + bsum, c[4]) << endl;
return 0;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
You are given a ternary string (it is a string which consists only of characters '0', '1' and '2').
You can swap any two adjacent (consecutive) characters '0' and '1' (i.e. replace "01" with "10" or vice versa) or any two adjacent (consecutive) characters '1' and '2' (i.e. replace "12" with "21" or vice versa).
For example, for string "010210" we can perform the following moves:
* "010210" → "100210";
* "010210" → "001210";
* "010210" → "010120";
* "010210" → "010201".
Note than you cannot swap "02" → "20" and vice versa. You cannot perform any other operations with the given string excluding described above.
You task is to obtain the minimum possible (lexicographically) string by using these swaps arbitrary number of times (possibly, zero).
String a is lexicographically less than string b (if strings a and b have the same length) if there exists some position i (1 ≤ i ≤ |a|, where |s| is the length of the string s) such that for every j < i holds a_j = b_j, and a_i < b_i.
Input
The first line of the input contains the string s consisting only of characters '0', '1' and '2', its length is between 1 and 10^5 (inclusive).
Output
Print a single string — the minimum possible (lexicographically) string you can obtain by using the swaps described above arbitrary number of times (possibly, zero).
Examples
Input
100210
Output
001120
Input
11222121
Output
11112222
Input
20
Output
20
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, s1 = "";
cin >> s;
long long int n = s.length(), c0 = 0, c1 = 0;
vector<int> v;
for (long long int i = 0; i < n; i++) {
if (s[i] == '1') c1++;
if (s[i] == '0') c0++;
if (s[i] == '2') {
v.push_back(c0);
c0 = 0;
}
}
v.push_back(c0);
n = v.size();
for (long long int i = 0; i < v[0]; i++) cout << 0;
for (long long int i = 0; i < c1; i++) cout << 1;
for (long long int i = 1; i < n; i++) {
cout << 2;
for (long long int j = 0; j < v[i]; j++) cout << 0;
}
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
Areas on the Cross-Section Diagram
Your task is to simulate a flood damage.
For a given cross-section diagram, reports areas of flooded sections.
<image>
Assume that rain is falling endlessly in the region and the water overflowing from the region is falling in the sea at the both sides. For example, for the above cross-section diagram, the rain will create floods which have areas of 4, 2, 1, 19 and 9 respectively.
output
Report the areas of floods in the following format:
$A$
$k$ $L_1$ $L_2$ ... $L_k$
In the first line, print the total area $A$ of created floods.
In the second line, print the number of floods $k$ and areas $L_i (i = 1, 2, ..., k)$ for each flood from the left side of the cross-section diagram. Print a space character before $L_i$.
Constraints
* $1 \leq$ length of the string $\leq 20,000$
Input
A string, which represents slopes and flatlands by '/', '\' and '_' respectively, is given in a line. For example, the region of the above example is given by a string "\\\///\\_/\/\\\\\\\/_/\\\///__\\\\\\_\\\/_\/_/\".
Examples
Input
\\//
Output
4
1 4
Input
\\///\_/\/\\\\/_/\\///__\\\_\\/_\/_/\
Output
35
5 4 2 1 19 9
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> P;
int main() {
string s;
stack<int> left_bank;
stack<P> pond;
int area = 0;
cin >> s;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '\\') {
left_bank.push(i);
} else if (s[i] == '/' && !left_bank.empty()) {
int j = left_bank.top();
left_bank.pop();
int sub_area = i - j;
area += sub_area;
while (!pond.empty() && j < pond.top().first) {
sub_area += pond.top().second;
pond.pop();
}
pond.emplace(j, sub_area);
}
}
vector<int> v;
while (!pond.empty()) {
v.push_back(pond.top().second);
pond.pop();
}
cout << area << "\n" << v.size();
for (int i = v.size() - 1; i >= 0; i--) {
cout << " " << v[i];
}
cout << "\n";
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
There exists an island called Arpa’s land, some beautiful girls live there, as ugly ones do.
Mehrdad wants to become minister of Arpa’s land. Arpa has prepared an exam. Exam has only one question, given n, print the last digit of 1378n.
<image>
Mehrdad has become quite confused and wants you to help him. Please help, although it's a naive cheat.
Input
The single line of input contains one integer n (0 ≤ n ≤ 109).
Output
Print single integer — the last digit of 1378n.
Examples
Input
1
Output
8
Input
2
Output
4
Note
In the first example, last digit of 13781 = 1378 is 8.
In the second example, last digit of 13782 = 1378·1378 = 1898884 is 4.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
set<char> st;
set<char>::iterator it;
map<char, int> mp;
map<char, int>::iterator itr;
pair<int, int> pr[1000000];
int ans[1000] = {0};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL), cout.tie(NULL);
long long a;
cin >> a;
if (a == 0)
cout << '1' << endl;
else if (a % 4 == 0)
cout << 6 << endl;
else if (a % 4 == 1)
cout << 8 << endl;
else if (a % 4 == 2)
cout << 4 << endl;
else if (a % 4 == 3)
cout << 2 << endl;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
One way to create task is to learn from game. You should pick a game and focus on part of the mechanic of that game, then it might be a good task.
Let's have a try. Puzzle and Dragon was a popular game in Japan, we focus on the puzzle part of that game, it is a tile-matching puzzle.
<image>(Picture from Wikipedia page: http://en.wikipedia.org/wiki/Puzzle_&_Dragons)
There is an n × m board which consists of orbs. During the game you can do the following move. In the beginning of move you touch a cell of the board, then you can move your finger to one of the adjacent cells (a cell not on the boundary has 8 adjacent cells), then you can move your finger from the current cell to one of the adjacent cells one more time, and so on. Each time you move your finger from a cell to another cell, the orbs in these cells swap with each other. In other words whatever move you make, the orb in the cell you are touching never changes.
The goal is to achieve such kind of pattern that the orbs will be cancelled and your monster will attack the enemy, but we don't care about these details. Instead, we will give you the initial board as an input and the target board as an output. Your goal is to determine whether there is a way to reach the target in a single move.
Input
The first line contains two integers: n and m (1 ≤ n, m ≤ 30).
The next n lines each contains m integers — the description of the initial board. The j-th integer in the i-th line is si, j (1 ≤ si, j ≤ 900), where si, j denotes the type of the orb located in the i-th row and j-th column of the board.
The next n lines contain the target board in the same format. Note, that the initial board and the target board will be different.
Output
If there is no solution, then output: -1.
If there is a solution, then in the first line output an integer k (1 ≤ k ≤ 106) — the number of finger moves.
In the next line print two integers x0 and y0 (1 ≤ x0 ≤ n; 1 ≤ y0 ≤ m) — the position of the cell you touch at the beginning. In each of the next k lines print two integers xi and yi (1 ≤ xi ≤ n; 1 ≤ yi ≤ m) — the position you move to. Note that this position must be adjacent to the previous position, that is max(|xi - xi - 1|, |yi - yi - 1|) = 1.
If there are multiple solutions, you can print any of them. We can prove that under these constraints if there exists a solution then there is a solution with no more than 106 operations.
Examples
Input
2 2
1 3
2 3
1 3
3 2
Output
3
1 1
2 2
2 1
1 1
Input
2 2
1 3
2 3
1 2
2 3
Output
-1
Input
1 4
1 2 3 4
4 3 2 1
Output
-1
Input
4 1
1
2
3
4
3
1
2
4
Output
2
3 1
2 1
1 1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m;
int s[35][35];
int t[35][35];
vector<pair<int, int> > ans;
vector<pair<int, int> > reverseList;
int x, y;
void performMove(int i, int j) {
swap(s[i][j], s[x][y]);
x = i;
y = j;
ans.push_back(make_pair(x, y));
}
bool check() {
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j)
if (s[i][j] != t[i][j]) return 0;
return 1;
}
bool mirror = 0;
void printAns() {
assert(ans.size() < 1000000);
printf("%d\n", ans.size() - 1);
for (int i = 0; i < ans.size(); ++i) {
if (mirror)
printf("%d %d\n", ans[i].second + 1, ans[i].first + 1);
else
printf("%d %d\n", ans[i].first + 1, ans[i].second + 1);
}
}
void reverse(int i, int j) {
reverseList.push_back(make_pair(x, y));
performMove(i, j);
}
void transpos(int i1, int j1, int i2, int j2) {
reverseList.clear();
if (i1 == i2) {
if (i1 == n - 1) {
reverse(x - 1, y);
while (y > j1) reverse(x, y - 1);
} else {
while (y > j1) reverse(x, y - 1);
while (x > i1 + 1) reverse(x - 1, y);
}
} else {
if (j1 == m - 1) {
reverse(x, y - 1);
} else {
while (y > j1 + 1) {
reverse(x, y - 1);
}
}
while (x > i1) reverse(x - 1, y);
}
int backx = x, backy = y;
performMove(i1, j1);
performMove(i2, j2);
performMove(backx, backy);
for (int i = reverseList.size() - 1; i >= 0; --i)
performMove(reverseList[i].first, reverseList[i].second);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) scanf("%d", s[i] + j);
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) scanf("%d", t[i] + j);
if (n == 1) {
mirror = 1;
for (int i = 0; i < m; ++i) {
s[i][0] = s[0][i];
t[i][0] = t[0][i];
}
n = m;
m = 1;
}
if (m == 1) {
int ssaved[35][35];
for (int k = 0; k < n; ++k)
for (int q = 0; q < m; ++q) ssaved[k][q] = s[k][q];
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
for (int k = 0; k < n; ++k)
for (int q = 0; q < m; ++q) s[k][q] = ssaved[k][q];
ans.clear();
x = i;
y = 0;
ans.push_back(make_pair(x, y));
int k = i;
while (k != j) {
if (k > j)
--k;
else
++k;
performMove(k, 0);
}
if (check()) {
printAns();
return 0;
}
}
}
puts("-1");
return 0;
}
for (int i = 0; i <= n; ++i) {
if (i == n) {
puts("-1");
return 0;
}
for (int j = 0; j < m; ++j) {
if (s[i][j] == t[n - 1][m - 1]) {
x = i;
y = j;
ans.push_back(make_pair(x, y));
while (x < n - 1) performMove(x + 1, y);
while (y < m - 1) performMove(x, y + 1);
i = n;
break;
}
}
if (i == n) break;
}
while (!check()) {
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
if (s[i][j] != t[i][j]) {
int k = i, l = j;
while (k < n) {
++l;
if (l == m) {
l = 0;
++k;
}
if (k == n - 1 && l == m - 1) {
puts("-1");
return 0;
}
if (s[k][l] == t[i][j]) {
break;
}
}
while (l != j) {
int lnew;
if (l > j)
lnew = l - 1;
else
lnew = l + 1;
if (lnew == m - 1 && k == n - 1) {
performMove(n - 1, m - 2);
performMove(n - 2, m - 1);
performMove(n - 1, m - 1);
--k;
} else
transpos(k, l, k, lnew);
l = lnew;
}
while (k != i) {
transpos(k - 1, l, k, l);
--k;
}
}
}
}
printAns();
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
This problem is a little bit unusual. Here you are to implement an interaction with a testing system. That means that you can make queries and get responses in the online mode. Please be sure to use the stream flushing operation after each query's output in order not to leave part of your output in some buffer. For example, in C++ you've got to use the fflush(stdout) function, in Java — call System.out.flush(), and in Pascal — flush(output).
Bulls and Cows (also known as Cows and Bulls or Pigs and Bulls or Bulls and Cleots) is an old code-breaking paper and pencil game for two players, predating the similar commercially marketed board game Mastermind.
On a sheet of paper, the first player thinks a secret string. This string consists only of digits and has the length 4. The digits in the string must be all different, no two or more equal digits are allowed.
Then the second player tries to guess his opponent's string. For every guess the first player gives the number of matches. If the matching digits are on their right positions, they are "bulls", if on different positions, they are "cows". Thus a response is a pair of numbers — the number of "bulls" and the number of "cows". A try can contain equal digits.
More formally, let's the secret string is s and the second player are trying to guess it with a string x. The number of "bulls" is a number of such positions i (1 ≤ i ≤ 4) where s[i] = x[i]. The number of "cows" is a number of such digits c that s contains c in the position i (i.e. s[i] = c), x contains c, but x[i] ≠ c.
For example, the secret string is "0427", the opponent's try is "0724", then the answer is 2 bulls and 2 cows (the bulls are "0" and "2", the cows are "4" and "7"). If the secret string is "0123", the opponent's try is "0330", then the answer is 1 bull and 1 cow.
In this problem you are to guess the string s that the system has chosen. You only know that the chosen string consists of 4 distinct digits.
You can make queries to the testing system, each query is the output of a single 4-digit string. The answer to the query is the number of bulls and number of cows. If the system's response equals "4 0", that means the interaction with your problem is over and the program must terminate. That is possible for two reasons — the program either guessed the number x or made an invalid action (for example, printed letters instead of digits).
Your program is allowed to do at most 50 queries.
You can hack solutions of other participants providing a 4-digit string containing distinct digits — the secret string.
Input
To read answers to the queries, the program must use the standard input.
The program will receive pairs of non-negative integers in the input, one pair per line. The first number in a pair is a number of bulls and the second one is a number of cows of the string s and the string xi printed by your program. If the system response equals "4 0", then your solution should terminate.
The testing system will let your program read the i-th pair of integers from the input only after your program displays the corresponding system query in the output: prints value xi in a single line and executes operation flush.
Output
The program must use the standard output to print queries.
Your program must output requests — 4-digit strings x1, x2, ..., one per line. After the output of each line the program must execute flush operation. The program should read the answer to the query from the standard input.
Your program is allowed to do at most 50 queries.
Examples
Input
0 1
2 0
1 1
0 4
2 1
4 0
Output
8000
0179
3159
3210
0112
0123
Note
The secret string s in the example is "0123".
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
const int INF = (int)1e9;
const long long LINF = (long long)1e18;
const long double PI = acos((long double)-1);
const long double EPS = 1e-9;
inline long long gcd(long long a, long long b) {
long long r;
while (b) {
r = a % b;
a = b;
b = r;
}
return a;
}
inline long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
inline long long fpow(long long n, long long k, int p = MOD) {
long long r = 1;
for (; k; k >>= 1) {
if (k & 1) r = r * n % p;
n = n * n % p;
}
return r;
}
template <class T>
inline int chkmin(T& a, const T& val) {
return val < a ? a = val, 1 : 0;
}
template <class T>
inline int chkmax(T& a, const T& val) {
return a < val ? a = val, 1 : 0;
}
template <class T>
inline T isqrt(T k) {
T r = sqrt(k) + 1;
while (r * r > k) r--;
return r;
}
template <class T>
inline T icbrt(T k) {
T r = cbrt(k) + 1;
while (r * r * r > k) r--;
return r;
}
inline void addmod(int& a, int val, int p = MOD) {
if ((a = (a + val)) >= p) a -= p;
}
inline void submod(int& a, int val, int p = MOD) {
if ((a = (a - val)) < 0) a += p;
}
inline int mult(int a, int b, int p = MOD) { return (long long)a * b % p; }
inline int inv(int a, int p = MOD) { return fpow(a, p - 2, p); }
void solve() {
vector<int> v;
for (int i = (0); i < (10); i++) {
string s = "";
for (int j = (0); j < (4); j++) s += char('0' + i);
cout << s << "\n";
cout.flush();
int x, y;
cin >> x >> y;
if (x == 4) return;
if (x + y > 0) v.push_back(i);
}
int p[] = {0, 1, 2, 3};
do {
string s = "";
for (int i = (0); i < (4); i++) s += char('0' + v[p[i]]);
cout << s << "\n";
cout.flush();
int x, y;
cin >> x >> y;
if (x == 4) {
return;
}
} while (next_permutation(p, p + 4));
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
solve();
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
You are given an array a[0 … n-1] of length n which consists of non-negative integers. Note that array indices start from zero.
An array is called good if the parity of each index matches the parity of the element at that index. More formally, an array is good if for all i (0 ≤ i ≤ n - 1) the equality i mod 2 = a[i] mod 2 holds, where x mod 2 is the remainder of dividing x by 2.
For example, the arrays [0, 5, 2, 1] and [0, 17, 0, 3] are good, and the array [2, 4, 6, 7] is bad, because for i=1, the parities of i and a[i] are different: i mod 2 = 1 mod 2 = 1, but a[i] mod 2 = 4 mod 2 = 0.
In one move, you can take any two elements of the array and swap them (these elements are not necessarily adjacent).
Find the minimum number of moves in which you can make the array a good, or say that this is not possible.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases in the test. Then t test cases follow.
Each test case starts with a line containing an integer n (1 ≤ n ≤ 40) — the length of the array a.
The next line contains n integers a_0, a_1, …, a_{n-1} (0 ≤ a_i ≤ 1000) — the initial array.
Output
For each test case, output a single integer — the minimum number of moves to make the given array a good, or -1 if this is not possible.
Example
Input
4
4
3 2 7 6
3
3 2 6
1
7
7
4 9 2 1 18 3 0
Output
2
1
-1
0
Note
In the first test case, in the first move, you can swap the elements with indices 0 and 1, and in the second move, you can swap the elements with indices 2 and 3.
In the second test case, in the first move, you need to swap the elements with indices 0 and 1.
In the third test case, you cannot make the array good.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void coutv(vector<long long> v) {
for (auto it : v) cout << it << " ";
cout << "\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long t;
cin >> t;
while (t--) {
long long n, cnt = 0, cnti = 0;
cin >> n;
vector<long long> a(n);
for (auto &x : a) cin >> x;
for (int i = 0; i < a.size(); i++) {
long long j = i + 1;
if (j & 1 && a[i] & 1) cnt++;
if (j % 2 == 0 && a[i] % 2 == 0) cnti++;
}
if (cnt == cnti) {
cout << cnt << endl;
} else
cout << -1 << endl;
}
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
You are given a matrix n × m, initially filled with zeroes. We define a_{i, j} as the element in the i-th row and the j-th column of the matrix.
Two cells of the matrix are connected if they share a side, and the elements in these cells are equal. Two cells of the matrix belong to the same connected component if there exists a sequence s_1, s_2, ..., s_k such that s_1 is the first cell, s_k is the second cell, and for every i ∈ [1, k - 1], s_i and s_{i + 1} are connected.
You are given q queries of the form x_i y_i c_i (i ∈ [1, q]). For every such query, you have to do the following:
1. replace the element a_{x, y} with c;
2. count the number of connected components in the matrix.
There is one additional constraint: for every i ∈ [1, q - 1], c_i ≤ c_{i + 1}.
Input
The first line contains three integers n, m and q (1 ≤ n, m ≤ 300, 1 ≤ q ≤ 2 ⋅ 10^6) — the number of rows, the number of columns and the number of queries, respectively.
Then q lines follow, each representing a query. The i-th line contains three integers x_i, y_i and c_i (1 ≤ x_i ≤ n, 1 ≤ y_i ≤ m, 1 ≤ c_i ≤ max(1000, ⌈ (2 ⋅ 10^6)/(nm) ⌉)). For every i ∈ [1, q - 1], c_i ≤ c_{i + 1}.
Output
Print q integers, the i-th of them should be equal to the number of components in the matrix after the first i queries are performed.
Example
Input
3 2 10
2 1 1
1 2 1
2 2 1
1 1 2
3 1 2
1 2 2
2 2 2
2 1 2
3 2 4
2 1 5
Output
2
4
3
3
4
4
4
2
2
4
### Response
```cpp
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string& s) { return '"' + s + '"'; }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto& x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
string s, t;
string one, two;
const int inf = 400, inf2 = 2e6 + 5;
int tab[inf][inf];
vector<pair<pair<int, int>, int> > add[inf2];
vector<pair<pair<int, int>, int> > rem[inf2];
vector<pair<int, int> > fin[inf2];
int ans[inf2];
pair<int, int> parent[inf][inf];
int act[inf][inf];
int glo = 1;
pair<int, int> fnd(pair<int, int> x) {
if (parent[x.first][x.second] == x) {
return x;
}
auto pr = fnd(parent[x.first][x.second]);
return parent[x.first][x.second] = pr;
}
int uni(pair<int, int> a, pair<int, int> b) {
if (act[a.first][a.second] != glo || act[b.first][b.second] != glo) return 0;
auto fa = fnd(a);
auto fb = fnd(b);
if (fa == fb) return 0;
parent[fa.first][fa.second] = fb;
return 1;
}
void calc(vector<pair<int, int> > start,
vector<pair<pair<int, int>, int> > work, int mul) {
if (work.size() == 0) return;
42;
glo++;
int n = start.size() + work.size();
for (auto x : start) {
parent[x.first][x.second] = x;
act[x.first][x.second] = glo;
}
for (auto x : work) {
parent[x.first.first][x.first.second] = x.first;
}
for (auto x : start) {
uni(x, {x.first - 1, x.second});
uni(x, {x.first + 1, x.second});
uni(x, {x.first, x.second - 1});
uni(x, {x.first, x.second + 1});
}
for (auto ev : work) {
auto x = ev.first;
act[x.first][x.second] = glo;
int cnt = 1;
cnt -= uni(x, {x.first - 1, x.second});
cnt -= uni(x, {x.first + 1, x.second});
cnt -= uni(x, {x.first, x.second - 1});
cnt -= uni(x, {x.first, x.second + 1});
int t = ev.second;
int val = cnt * mul;
42;
ans[ev.second] -= cnt * mul;
}
}
int32_t main() {
ios_base::sync_with_stdio(0);
int n, m, q;
cin >> n >> m >> q;
int ran = max(2e6 / (double)(n * m) + 1, (double)1010);
for (int i = 0; i < q; i++) {
int x, y, c;
cin >> x >> y >> c;
add[c].push_back({{x, y}, i});
rem[tab[x][y]].push_back({{x, y}, i});
tab[x][y] = c;
}
vector<pair<int, int> > zero;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
zero.push_back({i, j});
fin[tab[i][j]].push_back({i, j});
}
}
for (int i = 0; i < ran; i++) {
reverse(rem[i].begin(), rem[i].end());
}
calc({fin[0]}, rem[0], -1);
for (int i = 1; i < ran; i++) {
calc({}, add[i], 1);
calc(fin[i], rem[i], -1);
}
int v = 1;
for (int i = 0; i < q; i++) {
cout << (v -= ans[i]) << " ";
}
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
Mashmokh works in a factory. At the end of each day he must turn off all of the lights.
The lights on the factory are indexed from 1 to n. There are n buttons in Mashmokh's room indexed from 1 to n as well. If Mashmokh pushes button with index i, then each light with index not less than i that is still turned on turns off.
Mashmokh is not very clever. So instead of pushing the first button he pushes some of the buttons randomly each night. He pushed m distinct buttons b1, b2, ..., bm (the buttons were pushed consecutively in the given order) this night. Now he wants to know for each light the index of the button that turned this light off. Please note that the index of button bi is actually bi, not i.
Please, help Mashmokh, print these indices.
Input
The first line of the input contains two space-separated integers n and m (1 ≤ n, m ≤ 100), the number of the factory lights and the pushed buttons respectively. The next line contains m distinct space-separated integers b1, b2, ..., bm (1 ≤ bi ≤ n).
It is guaranteed that all lights will be turned off after pushing all buttons.
Output
Output n space-separated integers where the i-th number is index of the button that turns the i-th light off.
Examples
Input
5 4
4 3 1 2
Output
1 1 3 4 4
Input
5 5
5 4 3 2 1
Output
1 2 3 4 5
Note
In the first sample, after pressing button number 4, lights 4 and 5 are turned off and lights 1, 2 and 3 are still on. Then after pressing button number 3, light number 3 is turned off as well. Pressing button number 1 turns off lights number 1 and 2 as well so pressing button number 2 in the end has no effect. Thus button number 4 turned lights 4 and 5 off, button number 3 turned light 3 off and button number 1 turned light 1 and 2 off.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int l[n];
memset(l, 0, sizeof l);
int t;
for (int i = 0; i < m; i++) {
cin >> t;
t--;
for (int k = t; k < n; k++) {
if (l[k] != 0) break;
l[k] = t + 1;
}
}
for (int i = 0; i < n; i++) cout << l[i] << " ";
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
Alfred wants to buy a toy moose that costs c dollars. The store doesn’t give change, so he must give the store exactly c dollars, no more and no less. He has n coins. To make c dollars from his coins, he follows the following algorithm: let S be the set of coins being used. S is initially empty. Alfred repeatedly adds to S the highest-valued coin he has such that the total value of the coins in S after adding the coin doesn’t exceed c. If there is no such coin, and the value of the coins in S is still less than c, he gives up and goes home. Note that Alfred never removes a coin from S after adding it.
As a programmer, you might be aware that Alfred’s algorithm can fail even when there is a set of coins with value exactly c. For example, if Alfred has one coin worth $3, one coin worth $4, and two coins worth $5, and the moose costs $12, then Alfred will add both of the $5 coins to S and then give up, since adding any other coin would cause the value of the coins in S to exceed $12. Of course, Alfred could instead combine one $3 coin, one $4 coin, and one $5 coin to reach the total.
Bob tried to convince Alfred that his algorithm was flawed, but Alfred didn’t believe him. Now Bob wants to give Alfred some coins (in addition to those that Alfred already has) such that Alfred’s algorithm fails. Bob can give Alfred any number of coins of any denomination (subject to the constraint that each coin must be worth a positive integer number of dollars). There can be multiple coins of a single denomination. He would like to minimize the total value of the coins he gives Alfred. Please find this minimum value. If there is no solution, print "Greed is good". You can assume that the answer, if it exists, is positive. In other words, Alfred's algorithm will work if Bob doesn't give him any coins.
Input
The first line contains c (1 ≤ c ≤ 200 000) — the price Alfred wants to pay. The second line contains n (1 ≤ n ≤ 200 000) — the number of coins Alfred initially has. Then n lines follow, each containing a single integer x (1 ≤ x ≤ c) representing the value of one of Alfred's coins.
Output
If there is a solution, print the minimum possible total value of the coins in a solution. Otherwise, print "Greed is good" (without quotes).
Examples
Input
12
3
5
3
4
Output
5
Input
50
8
1
2
4
8
16
37
37
37
Output
Greed is good
Note
In the first sample, Bob should give Alfred a single coin worth $5. This creates the situation described in the problem statement.
In the second sample, there is no set of coins that will cause Alfred's algorithm to fail.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int cnt[200020], prv[200020];
int main() {
int c, n;
cin >> c >> n;
while (n--) {
int x;
cin >> x;
cnt[x]++;
}
for (int i = 1; i <= c + 1; i++) {
prv[i] = cnt[i - 1] ? i - 1 : prv[i - 1];
}
for (int i = 1; i <= c; i++) {
int t = c;
int m = max(prv[t + 1], i);
bool used = false;
while (t && m) {
int num = min(t / m, (m == i) + cnt[m]);
t -= m * num;
if (m == i) used = cnt[m] < num;
int nxt = prv[min(t + 1, m)];
if (m > i && nxt < i) nxt = i;
m = nxt;
}
if (t && used) {
cout << i << endl;
return 0;
}
}
cout << "Greed is good" << endl;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
A number is called almost prime if it has exactly two distinct prime divisors. For example, numbers 6, 18, 24 are almost prime, while 4, 8, 9, 42 are not. Find the amount of almost prime numbers which are between 1 and n, inclusive.
Input
Input contains one integer number n (1 ≤ n ≤ 3000).
Output
Output the amount of almost prime numbers between 1 and n, inclusive.
Examples
Input
10
Output
2
Input
21
Output
8
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
bool fn(int x);
int main() {
int n, i, k = 0;
scanf("%d", &n);
i = 6;
while (k < n && i <= n)
if (fn(i)) {
i++;
k++;
} else
i++;
printf("%d", k);
return 0;
}
bool fn(int x) {
int i = 2, a = x, b = 1, k = 0;
while (1) {
if (a % i == 0) {
a /= i;
if (i > b) {
k++;
b = i;
}
i = 2;
} else
i++;
if (a == 1) break;
}
if (k == 2) return 1;
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
ZS the Coder loves mazes. Your job is to create one so that he can play with it. A maze consists of n × m rooms, and the rooms are arranged in n rows (numbered from the top to the bottom starting from 1) and m columns (numbered from the left to the right starting from 1). The room in the i-th row and j-th column is denoted by (i, j). A player starts in the room (1, 1) and wants to reach the room (n, m).
Each room has four doors (except for ones at the maze border), one on each of its walls, and two adjacent by the wall rooms shares the same door. Some of the doors are locked, which means it is impossible to pass through the door. For example, if the door connecting (i, j) and (i, j + 1) is locked, then we can't go from (i, j) to (i, j + 1). Also, one can only travel between the rooms downwards (from the room (i, j) to the room (i + 1, j)) or rightwards (from the room (i, j) to the room (i, j + 1)) provided the corresponding door is not locked.
<image> This image represents a maze with some doors locked. The colored arrows denotes all the possible paths while a red cross denotes a locked door.
ZS the Coder considers a maze to have difficulty x if there is exactly x ways of travelling from the room (1, 1) to the room (n, m). Two ways are considered different if they differ by the sequence of rooms visited while travelling.
Your task is to create a maze such that its difficulty is exactly equal to T. In addition, ZS the Coder doesn't like large mazes, so the size of the maze and the number of locked doors are limited. Sounds simple enough, right?
Input
The first and only line of the input contains a single integer T (1 ≤ T ≤ 1018), the difficulty of the required maze.
Output
The first line should contain two integers n and m (1 ≤ n, m ≤ 50) — the number of rows and columns of the maze respectively.
The next line should contain a single integer k (0 ≤ k ≤ 300) — the number of locked doors in the maze.
Then, k lines describing locked doors should follow. Each of them should contain four integers, x1, y1, x2, y2. This means that the door connecting room (x1, y1) and room (x2, y2) is locked. Note that room (x2, y2) should be adjacent either to the right or to the bottom of (x1, y1), i.e. x2 + y2 should be equal to x1 + y1 + 1. There should not be a locked door that appears twice in the list.
It is guaranteed that at least one solution exists. If there are multiple solutions, print any of them.
Examples
Input
3
Output
3 2
0
Input
4
Output
4 3
3
1 2 2 2
3 2 3 3
1 3 2 3
Note
Here are how the sample input and output looks like. The colored arrows denotes all the possible paths while a red cross denotes a locked door.
In the first sample case:
<image>
In the second sample case:
<image>
### Response
```cpp
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target( \
"sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,tune=native")
using namespace std;
const long long N = 2e6 + 5;
const long long M = 70;
const long long SZ = 450;
const long long mod = 998244353;
const long long inf = 0x3f3f3f3f3f3f3f3f;
long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
void write(long long x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x >= 10) write(x / 10);
putchar(x % 10 + '0');
}
long long ksm(long long x, long long y = mod - 2, long long z = mod) {
long long ret = 1;
while (y) {
if (y & 1) ret = (ret * x) % z;
x = (x * x) % z;
y >>= 1;
}
return ret;
}
struct Four {
long long x1, _, x2, y2;
};
set<pair<pair<long long, long long>, pair<long long, long long> > > S;
void add(long long x1, long long _, long long x2, long long y2) {
if (x1 < 1 || _ < 1 || x2 < 1 || y2 < 1) return;
if (x1 + _ > x2 + y2) swap(x1, x2), swap(_, y2);
S.insert(make_pair(make_pair(x1, _), make_pair(x2, y2)));
}
long long X, Y;
void change(long long k) {
add(X - 2, X + 3, X - 1, X + 3);
add(X - 1, X + 1, X, X + 1);
add(X, X + 2, X, X + 3);
add(X, X + 4, X + 1, X + 4);
add(X + 1, X + 2, X + 1, X + 3);
add(X + 2, X, X + 3, X);
add(X + 2, X + 1, X + 3, X + 1);
add(X + 3, X - 2, X + 3, X - 1);
add(X + 4, X, X + 4, X + 1);
if (k % 3 == 0) add(X - 1, X + 2, X, X + 2);
if (k % 3 != 2) add(X + 2, X - 1, X + 2, X);
if (k < 3) add(X + 1, X - 1, X + 1, X);
X += 2;
Y += 2;
}
long long T;
long long a[N], t, sz;
signed main() {
T = read();
add(1, 2, 2, 2);
add(2, 1, 2, 2);
X = Y = 2;
while (T) a[++t] = T % 6, T /= 6;
for (long long i = t; i >= 1; i--) change(a[i]);
cout << X << " " << Y << endl;
for (pair<pair<long long, long long>, pair<long long, long long> > p : S) {
if (p.first.first > X || p.second.second > X || p.first.second > X ||
p.second.first > X)
sz++;
}
cout << S.size() - sz << endl;
for (pair<pair<long long, long long>, pair<long long, long long> > p : S) {
if (p.first.first > X || p.second.second > X || p.first.second > X ||
p.second.first > X)
continue;
cout << p.first.first << " " << p.first.second << " " << p.second.first
<< " " << p.second.second << "\n";
}
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
problem
You are playing with J using the Midakuji. The Amida lottery consists of n vertical bars and m horizontal bars. The vertical bars are numbered from 1 to n in order from the left, and the vertical bar i The positive integer si is written at the bottom of.
<image>
Figure 3-1 Example of Amidakuji (n = 4, m = 5, s1 = 20, s2 = 80, s3 = 100, s4 = 50)
The integer written at the bottom of the vertical bar i, which is reached by following the path from the top of the vertical bar i, is the score when the vertical bar i is selected. For example, in Fig. 3-1 the vertical bar 1 is selected. And the score is 80 points, and if the vertical bar 2 is selected, the score is 100 points.
<image>
Figure 3-2 Example of how to follow the road
Mr. J decides to choose a series of k books from vertical bar 1 to vertical bar k. The total score when selecting those k vertical bars is J's score. However, you are in the Amidakuji You can select one horizontal bar and delete that horizontal bar from the Amidakuji. (You do not have to delete it.) If you delete one horizontal bar, the vertical bar in the deleted Amidakuji will be displayed vertically. J's score is the total of the points when selecting k consecutive vertical bars from bar 1 to vertical bar k.
Given the shape of the Amida lottery and the number of vertical bars k that J chooses as input, create a program that finds the minimum value of J's score.
input
The input consists of multiple datasets. Each dataset is given in the following format.
On the first line, four integers n, m, h, k are written separated by blanks. N (2 ≤ n ≤ 1000) is the number of vertical bars, and m (1 ≤ m ≤ 100000) is the horizontal bar. H (2 ≤ h ≤ 1000) represents the length of the vertical bar, and k (1 ≤ k ≤ n) represents the number of vertical bars you choose.
The following n lines contain the score written at the bottom of the vertical bar. The first line (1 ≤ i ≤ n) contains the positive integer si. Also, s1 + s2 + ... + sn ≤ 2000000000 = 2 × 109.
The following m lines indicate the position of the horizontal bar. The horizontal bars are numbered from 1 to m. The first line (1 ≤ i ≤ m) is the horizontal bar i. The two integers ai, bi (1 ≤ ai ≤ n --1, 1 ≤ bi ≤ h --1) representing the position are separated by blanks, and the horizontal bar i connects the vertical bar ai and the vertical bar ai + 1. , Indicates that the distance from the top edge of the horizontal bar i is bi. However, no two horizontal bars share an endpoint.
Of the scoring data, 20% of the points will have the lowest score for Mr. J if the horizontal bar is not deleted. Also, 30% of the points will satisfy n ≤ 20, m ≤ 30, h ≤ 10. 60% of the points are m ≤ 1000.
The end of the input is indicated by a line containing four zeros. The number of datasets does not exceed 10.
output
For each dataset, output the minimum score of Mr. J on one line.
Examples
Input
4 5 7 2
20
80
100
50
1 1
2 6
2 3
1 5
3 1
2 2 5 1
10
20
1 1
1 3
0 0 0 0
Output
100
10
Input
None
Output
None
### Response
```cpp
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <climits>
#include <cfloat>
#include <ctime>
#include <map>
#include <utility>
#include <set>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <sstream>
#include <complex>
#include <stack>
#include <queue>
#include <numeric>
using namespace std;
#ifdef _MSC_VER
#define __typeof__ decltype
template <class T>
int __builtin_popcount(T n) { return n ? 1 + __builtin_popcount(n & (n - 1)) : 0; }
#endif
#define foreach(it, c) for (__typeof__((c).begin()) it=(c).begin(); it != (c).end(); ++it)
#define all(c) (c).begin(), (c).end()
#define rall(c) (c).rbegin(), (c).rend()
#define popcount __builtin_popcount
template <class T> void max_swap(T& a, const T b) { a = max(a, b); }
template <class T> void min_swap(T& a, const T b) { a = min(a, b); }
const double EPS = 1e-10;
typedef long long ll;
typedef pair<int, int> pint;
struct swap_info { int no1, no2, p1, p2; };
int main()
{
int n, m, h, k;
while (scanf("%d%d%d%d", &n, &m, &h, &k), n | m | h | k)
{
int s[1024];
static pint stick[100100];
for (int i = 0; i < n; ++i)
scanf("%d", s + i);
for (int i = 0; i < m; ++i)
{
int a, b;
scanf("%d%d", &a, &b);
stick[i] = pint(b, a - 1);
}
sort(stick, stick + m);
static pint swap_pair[100100];
int no[1024];
for (int i = 0; i < n; ++i)
no[i] = i;
for (int i = 0; i < m; ++i)
{
int x = stick[i].second;
swap_pair[i].first = no[x];
swap_pair[i].second = no[x + 1];
swap(no[x], no[x + 1]);
}
int p[1024];
for (int i = 0; i < n; ++i)
p[i] = s[i];
int max_sub = 0;
for (int i = m - 1; i >= 0; --i)
{
int x = stick[i].second;
swap(p[x], p[x + 1]);
pint a(swap_pair[i].first, p[x]);
pint b(swap_pair[i].second, p[x + 1]);
if (a > b)
swap(a, b);
if (a.first < k && k <= b.first)
max_swap(max_sub, a.second - b.second);
}
printf("%d\n", accumulate(p, p + k, 0) - max_sub);
}
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
Every year, hundreds of people come to summer camps, they learn new algorithms and solve hard problems.
This is your first year at summer camp, and you are asked to solve the following problem. All integers starting with 1 are written in one line. The prefix of these line is "123456789101112131415...". Your task is to print the n-th digit of this string (digits are numbered starting with 1.
Input
The only line of the input contains a single integer n (1 ≤ n ≤ 1000) — the position of the digit you need to print.
Output
Print the n-th digit of the line.
Examples
Input
3
Output
3
Input
11
Output
0
Note
In the first sample the digit at position 3 is '3', as both integers 1 and 2 consist on one digit.
In the second sample, the digit at position 11 is '0', it belongs to the integer 10.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n > 0 && n < 10)
cout << n;
else if (n > 9 && n <= 189) {
n = n - 9;
if (n % 2 == 0) {
n = 9 + n / 2;
cout << n % 10;
} else {
n = 9 + n / 2 + 1;
n = n / 10;
cout << n % 10;
}
} else {
n = n - 189;
int z = 100 + n / 3;
if (n % 3 == 0)
cout << (z - 1) % 10;
else if (n % 3 == 2) {
z = z / 10;
cout << z % 10;
} else {
z = z / 100;
cout << z % 10;
}
}
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Firecrackers scare Nian the monster, but they're wayyyyy too noisy! Maybe fireworks make a nice complement.
Little Tommy is watching a firework show. As circular shapes spread across the sky, a splendid view unfolds on the night of Lunar New Year's eve.
A wonder strikes Tommy. How many regions are formed by the circles on the sky? We consider the sky as a flat plane. A region is a connected part of the plane with positive area, whose bound consists of parts of bounds of the circles and is a curve or several curves without self-intersections, and that does not contain any curve other than its boundaries. Note that exactly one of the regions extends infinitely.
Input
The first line of input contains one integer n (1 ≤ n ≤ 3), denoting the number of circles.
The following n lines each contains three space-separated integers x, y and r ( - 10 ≤ x, y ≤ 10, 1 ≤ r ≤ 10), describing a circle whose center is (x, y) and the radius is r. No two circles have the same x, y and r at the same time.
Output
Print a single integer — the number of regions on the plane.
Examples
Input
3
0 0 1
2 0 1
4 0 1
Output
4
Input
3
0 0 2
3 0 2
6 0 2
Output
6
Input
3
0 0 2
2 0 2
1 1 2
Output
8
Note
For the first example,
<image>
For the second example,
<image>
For the third example,
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
const double PI = acos(-1);
bool eq(double a, double b) { return abs(a - b) < EPS; }
bool lt(double a, double b) { return (a - b < -EPS); }
bool gt(double a, double b) { return (a - b > EPS); }
bool leq(double a, double b) { return a - b < EPS; }
bool geq(double a, double b) { return a - b > -EPS; }
double mySqrt(double a) { return (eq(a, 0) ? 0 : sqrt(a)); }
double sqr(double a) { return a * a; }
struct Point {
Point(){};
Point(double x, double y) : x(x), y(y) {}
double x;
double y;
Point operator+=(const Point &other) {
x = x + other.x;
y = y + other.y;
return *this;
}
Point operator+(const Point &other) const {
Point temp = *this;
return temp += other;
}
Point operator-=(const Point &other) {
x = x - other.x;
y = y - other.y;
return *this;
}
Point operator-(const Point &other) const {
Point temp = *this;
return temp -= other;
}
Point operator*(double c) const { return Point{x * c, y * c}; }
Point operator/(double c) const { return Point{x / c, y / c}; }
bool operator==(const Point &other) const {
return eq(x, other.x) && eq(y, other.y);
}
bool operator<(const Point &other) const {
if (eq(x, other.x)) return lt(y, other.y);
return lt(x, other.x);
}
bool operator>(const Point &other) const {
if (eq(x, other.x)) return gt(y, other.y);
return gt(x, other.x);
}
};
istream &operator>>(std::istream &stream, Point &a) {
stream >> a.x >> a.y;
return stream;
}
ostream &operator<<(std::ostream &stream, const Point &a) {
stream << a.x << " " << a.y;
return stream;
}
double cross(const Point &a, const Point &b) { return a.x * b.y - a.y * b.x; }
double dot(const Point &a, const Point &b) { return a.x * b.x + a.y * b.y; }
double dist(const Point &a) { return mySqrt(dot(a, a)); }
double dist(const Point &a, const Point &b) {
return mySqrt(dot(a - b, a - b));
}
Point footPerp(const Point &a, const Point &b, const Point &c) {
double x = dot(a - b, c - b) / dist(c - b);
return b + (c - b) * (x / dist(c - b));
}
double dist(const Point &a, const Point &b, const Point &c) {
return dist(a - footPerp(a, b, c));
}
vector<Point> intersect(const Point &cen1, double r1, const Point &cen2,
double r2) {
double d = dist(cen1 - cen2);
if (lt(r1 + r2, d) || gt(abs(r1 - r2), d)) return {};
double l = ((sqr(r1) - sqr(r2)) / d + d) / 2;
double h = mySqrt(sqr(r1) - sqr(l));
Point a = cen1 + (cen2 - cen1) * (l / d);
Point b = {(cen2 - cen1).y, -(cen2 - cen1).x};
b = b * (h / dist(cen2 - cen1));
if (b == Point{0, 0}) return {a};
return {a + b, a - b};
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<Point> a(n);
vector<int> r(n);
for (int i = 0; i < n; ++i) {
cin >> a[i] >> r[i];
}
if (n == 1) {
cout << 2 << endl;
return 0;
}
if (n == 2) {
vector<Point> d = intersect(a[0], r[0], a[1], r[1]);
if ((int)(d).size() == 2) {
cout << 4 << endl;
} else {
cout << 3 << endl;
}
return 0;
}
vector<Point> c;
vector<vector<Point>> b(n);
int cnt = 0;
for (int i = 0; i < n; ++i) {
int j = (i + 1) % n;
vector<Point> d = intersect(a[i], r[i], a[j], r[j]);
for (int k = 0; k < (int)(d).size(); ++k) {
b[i].push_back(d[k]);
b[j].push_back(d[k]);
c.push_back(d[k]);
}
if ((int)(d).size() != 0) {
++cnt;
}
}
sort((c).begin(), (c).end());
c.resize(unique((c).begin(), (c).end()) - c.begin());
for (int i = 0; i < n; ++i) {
sort((b[i]).begin(), (b[i]).end());
b[i].resize(unique((b[i]).begin(), (b[i]).end()) - b[i].begin());
}
int v = (int)(c).size();
int e = 0;
for (int i = 0; i < n; ++i) {
e += (int)(b[i]).size();
}
int comp = max(1, n - cnt);
int f = e - v + comp + 1;
cout << f << endl;
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Sereja has two sequences a and b and number p. Sequence a consists of n integers a1, a2, ..., an. Similarly, sequence b consists of m integers b1, b2, ..., bm. As usual, Sereja studies the sequences he has. Today he wants to find the number of positions q (q + (m - 1)·p ≤ n; q ≥ 1), such that sequence b can be obtained from sequence aq, aq + p, aq + 2p, ..., aq + (m - 1)p by rearranging elements.
Sereja needs to rush to the gym, so he asked to find all the described positions of q.
Input
The first line contains three integers n, m and p (1 ≤ n, m ≤ 2·105, 1 ≤ p ≤ 2·105). The next line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109). The next line contains m integers b1, b2, ..., bm (1 ≤ bi ≤ 109).
Output
In the first line print the number of valid qs. In the second line, print the valid values in the increasing order.
Examples
Input
5 3 1
1 2 3 2 1
1 2 3
Output
2
1 3
Input
6 3 2
1 3 2 2 3 1
1 2 3
Output
2
1 2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200000 + 5;
int n, m, p, a[maxn], b[maxn];
struct T {
void ins(int x) {
int &t = f[x];
s -= abs(t);
++t;
s += abs(t);
}
void del(int x) {
int &t = f[x];
s -= abs(t);
--t;
s += abs(t);
}
bool check() { return s == 0; }
map<int, int> f;
int s;
} t;
int main() {
scanf("%d%d%d", &n, &m, &p);
for (int i = 0; i < n; ++i) scanf("%d", a + i);
for (int i = 0; i < m; ++i) {
scanf("%d", b + i);
t.del(b[i]);
}
vector<int> ans;
for (int i = 0; i < p; ++i)
if (i < n) {
int j = i, k = i;
while (j < n) {
t.ins(a[j]);
j += p;
if ((j - k) / p > m) {
t.del(a[k]);
k += p;
}
if ((j - k) / p == m && t.check()) ans.push_back(k);
}
while (k < j) {
t.del(a[k]);
k += p;
}
}
sort(ans.begin(), ans.end());
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); ++i) cout << ans[i] + 1 << " ";
cout << endl;
return 0;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
You have an array a_1, a_2, ..., a_n. All a_i are positive integers.
In one step you can choose three distinct indices i, j, and k (i ≠ j; i ≠ k; j ≠ k) and assign the sum of a_j and a_k to a_i, i. e. make a_i = a_j + a_k.
Can you make all a_i lower or equal to d using the operation above any number of times (possibly, zero)?
Input
The first line contains a single integer t (1 ≤ t ≤ 2000) — the number of test cases.
The first line of each test case contains two integers n and d (3 ≤ n ≤ 100; 1 ≤ d ≤ 100) — the number of elements in the array a and the value d.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 100) — the array a.
Output
For each test case, print YES, if it's possible to make all elements a_i less or equal than d using the operation above. Otherwise, print NO.
You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer).
Example
Input
3
5 3
2 3 2 5 4
3 4
2 4 4
5 4
2 1 5 3 6
Output
NO
YES
YES
Note
In the first test case, we can prove that we can't make all a_i ≤ 3.
In the second test case, all a_i are already less or equal than d = 4.
In the third test case, we can, for example, choose i = 5, j = 1, k = 2 and make a_5 = a_1 + a_2 = 2 + 1 = 3. Array a will become [2, 1, 5, 3, 3].
After that we can make a_3 = a_5 + a_2 = 3 + 1 = 4. Array will become [2, 1, 4, 3, 3] and all elements are less or equal than d = 4.
### Response
```cpp
#include<iostream>
#include<vector>
#include<algorithm>
#include<stdlib.h>
#include<time.h>
#include<math.h>
#include<stdio.h>
#include<string>
#include<set>
#include<iomanip>
#include<numeric>
#include<map>
#include<limits>
#include<unordered_set>
#include<array>
#include<deque>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
std::cout.tie(0);
long long t, q, x, l, y, r, g, k, c, m, p;
long long n;
string s;
cin >> t;
while (t--)
{
cin >> n >> k;
vector<int>a(n);
int flag = 0;
for (int i = 0; i < n; i++)
{
cin >> a[i];
if (a[i] > k)
{
flag = 1;
}
}
if (flag == 0)
{
cout << "YES";
}
else {
sort(a.begin(), a.end());
if (a[0] + a[1] <= k)
{
cout << "YES";
}
else {
cout << "NO";
}
}
cout << endl;
}
return 0;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
Rng is going to a festival.
The name of the festival is given to you as a string S, which ends with `FESTIVAL`, from input. Answer the question: "Rng is going to a festival of what?" Output the answer.
Here, assume that the name of "a festival of s" is a string obtained by appending `FESTIVAL` to the end of s. For example, `CODEFESTIVAL` is a festival of `CODE`.
Constraints
* 9 \leq |S| \leq 50
* S consists of uppercase English letters.
* S ends with `FESTIVAL`.
Input
Input is given from Standard Input in the following format:
S
Output
Print the answer to the question: "Rng is going to a festival of what?"
Examples
Input
CODEFESTIVAL
Output
CODE
Input
CODEFESTIVALFESTIVAL
Output
CODEFESTIVAL
Input
YAKINIKUFESTIVAL
Output
YAKINIKU
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string s; cin >> s;
cout << s.substr(0, s.length() - 8) << endl;
return 0;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
Due to the success of TWICE, JYP Entertainment has earned countless money and emerged as the biggest entertainment firm by market capitalization. Therefore, the boss, JYP, has decided to create a new nation and has appointed you to provide a design diagram.
The new nation consists of n cities and some roads between them. JYP has given some restrictions:
* To guarantee efficiency while avoiding chaos, for any 2 different cities A and B, there is exactly one road between them, and it is one-directional. There are no roads connecting a city to itself.
* The logo of rivaling companies should not appear in the plan, that is, there does not exist 4 distinct cities A,B,C,D , such that the following configuration occurs.
<image>
JYP has given criteria for your diagram. For two cities A,B, let dis(A,B) be the smallest number of roads you have to go through to get from A to B. If it is not possible to walk from A to B, dis(A,B) = 614n. Then, the efficiency value is defined to be the sum of dis(A,B) for all ordered pairs of distinct cities (A,B).
Note that dis(A,B) doesn't have to be equal to dis(B,A).
You have drawn a design diagram that satisfies JYP's restrictions. Find the sum of dis(A,B) over all ordered pairs of cities (A,B) with A≠ B.
Note that the input is given in compressed form. But even though it is compressed, you'd better use fast input.
Input
The first line contains a single integer n (4 ≤ n ≤ 8000, n ≡ 0 \pmod{4}) — the number of cities.
A binary matrix is encrypted in the following format. Each of n next lines contains n/4 one-digit hexadecimal numbers (that is, these numbers can be represented either as digits from 0 to 9 or as uppercase Latin letters from A to F). Binary representation of each of these numbers denotes next 4 elements of the matrix in the corresponding row. For example, if the number B is given, then the corresponding elements are 1011, and if the number is 5, then the corresponding elements are 0101.
After you obtain the decrypted binary matrix, the j-th character of the i-th row is 1 if the one-directional road between cities i and j is directed from i to j, and 0 otherwise. It is guaranteed that the graph satisfies the restrictions mentioned above.
Output
Output one integer, representing the sum of dis(A,B) over all ordered pairs of cities (A,B) with A≠ B.
Examples
Input
4
7
2
1
4
Output
7380
Input
8
7F
3F
1F
0C
06
03
11
18
Output
88464
Note
The first example corresponds to the matrix:
\begin{matrix} 0111 \\\ 0010 \\\ 0001 \\\ 0100 \\\ \end{matrix}
Which corresponds to this graph:
<image>
dis(1,2)=dis(1,3)=dis(1,4)=dis(2,3)=dis(3,4)=dis(4,2)=1
dis(2,4)=dis(4,3)=dis(3,2)=2
dis(2,1)=dis(3,1)=dis(4,1)=2456
Therefore the answer for the diagram is 7380.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 8e3 + 7;
bool fl[N];
long long val;
bool f[N][N];
char p;
int n, cnt, opt, q[N], g[N];
inline void tarjan(int u) {
q[++cnt] = u, g[u] = ++opt, fl[u] = 1;
int c = opt;
for (int i = 1; i <= n; i++) {
if (!f[u][i]) continue;
if (!g[i]) tarjan(i);
if (fl[i]) g[u] = min(g[u], g[i]);
}
if (g[u] == c) {
while (q[cnt + 1] != u) fl[q[cnt]] = 0, g[q[cnt]] = c, cnt--;
}
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n / 4; j++) {
int c = 0;
char p = getchar();
while (!(('0' <= p && p <= '9') || ('A' <= p && p <= 'F'))) p = getchar();
if ('0' <= p && p <= '9')
c = p - '0';
else
c = p - 'A' + 10;
for (int x = 0; x <= 3; x++)
if (c & (1 << x)) f[i][j * 4 - x] = 1;
}
}
for (int i = 1; i <= n; i++)
if (!g[i]) tarjan(i);
for (int i = 1; i <= n; i++) {
int w = 0;
for (int j = 1; j <= n; j++)
if (!w && f[i][j])
w = j;
else if (f[i][j] && f[w][j])
w = j;
for (int j = 1; j <= n; j++) {
if (i == j) continue;
if (f[i][j])
val++;
else if (f[w][j])
val += 2;
else if (g[i] == g[j])
val += 3;
else
val += 614 * n;
}
}
cout << val << endl;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
One university has just found out about a sport programming contest called ACM ICPC v2.0. This contest doesn't differ much from the well-known ACM ICPC, for example, the participants are not allowed to take part in the finals more than two times. However, there is one notable difference: the teams in the contest should consist of exactly n participants.
Having taken part in several ACM ICPC v2.0 finals and having not won any medals, the students and the university governors realized that it's high time they changed something about the preparation process. Specifically, as the first innovation it was decided to change the teams' formation process. Having spent considerable amount of time on studying the statistics of other universities' performance, they managed to receive some interesting information: the dependence between the probability of winning a medal and the number of team members that participated in the finals in the past. More formally, we know n + 1 real numbers p0 ≤ p1 ≤ ... ≤ pn, where pi is the probability of getting a medal on the finals if the team has i participants of previous finals, and other n - i participants arrived to the finals for the first time.
Despite such useful data, the university governors are unable to determine such team forming tactics that would provide the maximum probability of winning a medal at ACM ICPC v2.0 finals on average (we are supposed to want to provide such result to the far future and we are also supposed to have an endless supply of students). And how about you, can you offer such optimal tactic? At the first stage the university governors want to know the value of maximum average probability.
More formally, suppose that the university sends a team to the k-th world finals. The team has ak participants of previous finals (0 ≤ ak ≤ n). Since each person can participate in the finals no more than twice, the following condition must be true: <image>. Your task is to choose sequence <image> so that the limit Ψ exists and it's value is maximal:
<image>
As <image> is an infinite sequence, you should only print the maximum value of the Ψ limit.
Input
The first line contains an integer n (3 ≤ n ≤ 100), n is the number of team participants. The second line contains n + 1 real numbers with no more than 6 digits after decimal point pi (0 ≤ i ≤ n, 0 ≤ pi ≤ 1) — the probability of that the team will win a medal if it contains i participants who has already been on the finals. Also the condition pi ≤ pi + 1 should be fulfilled for all 0 ≤ i ≤ n - 1.
Output
Print the only real number — the expected average number of medals won per year if the optimal strategy is used. The result may have absolute or relative error 10 - 6.
Examples
Input
3
0.115590 0.384031 0.443128 0.562356
Output
0.4286122500
Input
3
1 1 1 1
Output
0.9999999999
Note
In the second test, no matter what participants the team contains, it is doomed to be successful.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n;
double Max = -0.0;
double p[100001];
int main() {
scanf("%d", &n);
for (int i = 0; i <= n; i++) scanf("%lf", &p[i]);
for (int i = 0; i <= (n >> 1); i++)
for (int j = (n >> 1) + 1; j <= n; j++) {
double ans = 0.0;
ans += p[i] * (j * 2 - n);
if (ans <= 0.0) continue;
ans += p[j] * (n - i * 2);
if (ans <= 0.0) continue;
ans /= 2.0;
Max = max(Max, ans / ((j - i) * 1.0));
}
printf("%.10lf\n", Max);
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
D: Anipero 2012
Anipero Summer Live, commonly known as Anipero, is the largest anime song live event in Japan where various anime song artists gather. 2D, who loves anime songs, decided to go to Anipero this year as well as last year.
He has already purchased m of psyllium to enjoy Anipero. Psyllium is a stick that glows in a chemical reaction when folded. By shaking the psyllium in time with the rhythm, you can liven up the live performance and increase your satisfaction. All the psylliums he purchased this time have the following properties.
* The psyllium becomes darker as time passes after it is folded, and loses its light in 10 minutes.
* Very bright for 5 minutes after folding (hereinafter referred to as "level 2").
* It will be a little dark 5 minutes after folding (hereinafter referred to as "level 1").
* The speed at which light is lost does not change whether it is shaken or not.
2D decided to consider the following problems as to how satisfied he would be with this year's Anipero by properly using the limited psyllium depending on the song.
He anticipates n songs that will be played during the live. The length of each song is 5 minutes. n songs continue to flow, and the interval between songs can be considered as 0 minutes. The following three parameters are given to each song.
* Satisfaction that increases when only one level 2 is shaken for a certain song
* Satisfaction that increases when only one level 1 is shaken for a certain song
* Satisfaction increases when no song is shaken in a certain song
Shaking the glow stick does not necessarily increase satisfaction. If you shake it, it may disturb the atmosphere of the venue and reduce your satisfaction. The same can be said when not shaking.
Psyllium must be used according to the following rules.
* You can fold only when the song starts, and you can fold as many as you like at one time. The time it takes to fold the psyllium can be ignored.
* Up to 8 songs can be played at the same time in one song.
* When shaking multiple psylliums, calculate the satisfaction level to be added by the following formula.
* (Number of Level 1) x (Satisfaction per level 1) + (Number of Level 2) x (Satisfaction per Level 2)
* If no psyllium is shaken, only the satisfaction level when no one is shaken is added.
* Once you decide to shake the psyllium, you cannot change it until the end of one song.
* The psyllium can be left unshaken. Also, it is not necessary to use up all the psyllium.
2D had finished predicting the live song, but he was tired of it and didn't feel like solving the problem. Your job is to write a program for him that seeks the maximum satisfaction you're likely to get at this year's live concert.
Input
Satisfaction information for the expected song list of the live is input.
On the first line, the number of songs n (1 <= n <= 50) sung live and the number m (0 <= m <= 50) of new psyllium that 2D has at the start of the live are separated by spaces. Is entered in. In the following n lines, the information of one song is input line by line. The i-th (1 <= i <= n) song information is
* Satisfaction level when one level 2 psyllium is shaken for song i ai
* Satisfaction level bi when swinging one level 1 psyllium for song i
* Satisfaction ci when no psyllium is shaken in song i
Are entered separated by spaces (-100 <= ai, bi, ci <= 100).
Output
Output the prediction of 2D's maximum satisfaction at the end of the live in one line. Please note that the maximum satisfaction level may be negative. Output a line break at the end of the line.
Sample Input 1
1 5
2 3 8
Sample Output 1
Ten
Sample Input 2
2 10
2 2 20
2 3 -10
Sample Output 2
44
Sample Input 3
3 10
5 1 9
-3 2 1
1 11 0
Sample Output 3
102
Example
Input
1 5
2 3 8
Output
10
### Response
```cpp
//Name: Anipero 2012
//Level: 2
//Category: 動的計画法,DP
//Note:
/*
* [i曲目][残り本数][レベル2を振る本数] = 累計満足度でDP。
* 更新は、レベル1をl本振るとして、dp[i][j][k] = max(∀l,k'. dp[i-1][j+max(l-k',0)+k][k'] + f(i,l,k))
* （レベル1を増やしたいとき、過去に遡って折っていたことにする；初日はレベル1を振れないことに注意）。
* サイリウムを折っても、必ずしも振る必要はないことに注意。
*
* オーダーは O(NML^3)。
* ただし、Lは同時に使えるサイリウムの最大本数で、L=8。
*/
#include <iostream>
#include <array>
using namespace std;
template <typename T>
struct Maybe {
T val;
bool valid;
Maybe() : valid(false) {}
Maybe(T &t) : val(t), valid(true) {}
T& operator =(const T &rv) {
val = rv;
valid = true;
return val;
}
};
bool solve() {
int N, M;
if(!(cin >> N >> M)) return false;
array<array<array<Maybe<int>,9>,51>,51> dp;
dp[0][M][0] = 0;
for(int i = 1; i <= N; ++i) {
int a, b, c;
cin >> a >> b >> c;
for(int j = 0; j <= M; ++j) {
for(int k = 0; k <= 8; ++k) {
for(int l = 0; l <= 8-k; ++l) {
if(i == 1 && l > 0) break;
const int add = (k+l == 0) ? c : l*b + k*a;
for(int pk = 0; pk <= 8; ++pk) {
const int pj = j + max(0, l-pk) + k;
if(pj < 0 || pj > M) continue;
if(!dp[i-1][pj][pk].valid) continue;
const int ns = dp[i-1][pj][pk].val + add;
if(!dp[i][j][k].valid || dp[i][j][k].val < ns) dp[i][j][k] = ns;
}
}
}
}
}
Maybe<int> ans;
for(int j = 0; j <= M; ++j) {
for(int k = 0; k <= 8; ++k) {
if(dp[N][j][k].valid) {
const int v = dp[N][j][k].val;
if(!ans.valid || ans.val < v) ans = v;
}
}
}
cout << ans.val << endl;
return true;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(0);
while(solve()) ;
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
You are given a matrix with n rows (numbered from 1 to n) and m columns (numbered from 1 to m). A number a_{i, j} is written in the cell belonging to the i-th row and the j-th column, each number is either 0 or 1.
A chip is initially in the cell (1, 1), and it will be moved to the cell (n, m). During each move, it either moves to the next cell in the current row, or in the current column (if the current cell is (x, y), then after the move it can be either (x + 1, y) or (x, y + 1)). The chip cannot leave the matrix.
Consider each path of the chip from (1, 1) to (n, m). A path is called palindromic if the number in the first cell is equal to the number in the last cell, the number in the second cell is equal to the number in the second-to-last cell, and so on.
Your goal is to change the values in the minimum number of cells so that every path is palindromic.
Input
The first line contains one integer t (1 ≤ t ≤ 200) — the number of test cases.
The first line of each test case contains two integers n and m (2 ≤ n, m ≤ 30) — the dimensions of the matrix.
Then n lines follow, the i-th line contains m integers a_{i, 1}, a_{i, 2}, ..., a_{i, m} (0 ≤ a_{i, j} ≤ 1).
Output
For each test case, print one integer — the minimum number of cells you have to change so that every path in the matrix is palindromic.
Example
Input
4
2 2
1 1
0 1
2 3
1 1 0
1 0 0
3 7
1 0 1 1 1 1 1
0 0 0 0 0 0 0
1 1 1 1 1 0 1
3 5
1 0 1 0 0
1 1 1 1 0
0 0 1 0 0
Output
0
3
4
4
Note
The resulting matrices in the first three test cases:
\begin{pmatrix} 1 & 1\\\ 0 & 1 \end{pmatrix} \begin{pmatrix} 0 & 0 & 0\\\ 0 & 0 & 0 \end{pmatrix} \begin{pmatrix} 1 & 0 & 1 & 1 & 1 & 1 & 1\\\ 0 & 1 & 1 & 0 & 1 & 1 & 0\\\ 1 & 1 & 1 & 1 & 1 & 0 & 1 \end{pmatrix}
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
int a[n][m], p[n + m - 1], q[n + m - 1];
for (int i = 0; i < n + m - 1; i++) {
p[i] = 0;
q[i] = 0;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> a[i][j];
if (a[i][j] == 0)
p[i + j]++;
else
q[i + j]++;
}
}
int ind = (n + m - 2) / 2, ans = 0;
for (int i = 0; i <= ind; i++) {
int x = p[i] + p[m + n - 2 - i];
int y = q[i] + q[m + n - 2 - i];
if ((m + n) % 2 == 0 && i == ind) {
continue;
} else
ans += min(x, y);
}
cout << ans << "\n";
}
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
John Doe has an n × m table. John Doe can paint points in some table cells, not more than one point in one table cell. John Doe wants to use such operations to make each square subtable of size n × n have exactly k points.
John Doe wondered, how many distinct ways to fill the table with points are there, provided that the condition must hold. As this number can be rather large, John Doe asks to find its remainder after dividing by 1000000007 (109 + 7).
You should assume that John always paints a point exactly in the center of some cell. Two ways to fill a table are considered distinct, if there exists a table cell, that has a point in one way and doesn't have it in the other.
Input
A single line contains space-separated integers n, m, k (1 ≤ n ≤ 100; n ≤ m ≤ 1018; 0 ≤ k ≤ n2) — the number of rows of the table, the number of columns of the table and the number of points each square must contain.
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
In a single line print a single integer — the remainder from dividing the described number of ways by 1000000007 (109 + 7).
Examples
Input
5 6 1
Output
45
Note
Let's consider the first test case:
<image> The gray area belongs to both 5 × 5 squares. So, if it has one point, then there shouldn't be points in any other place. If one of the white areas has a point, then the other one also must have a point. Thus, there are about 20 variants, where the point lies in the gray area and 25 variants, where each of the white areas contains a point. Overall there are 45 variants.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 105, mod = 1e9 + 7;
int dp[N][N * N];
bool done[N][N * N];
int fact[N], inv[N];
int arr1[N];
int arr2[N];
int n, k;
long long m;
inline int add(int a, int b) {
int res = a + b;
if (res >= mod) res -= mod;
return res;
}
inline int mult(int a, int b) {
long long res = a * 1LL * b;
return res % mod;
}
int powmod(int a, long long b) {
int res = 1;
while (b) {
if (b & 1) {
res = mult(res, a);
}
a = mult(a, a);
b >>= 1;
}
return res;
}
int ncr(int n, int r) {
int res = fact[n];
res = mult(res, inv[r]);
res = mult(res, inv[n - r]);
return res;
}
int solve(int pos, int cnt) {
if (cnt < 0) return 0;
if (pos == n + 1) return (cnt == 0);
if (done[pos][cnt]) return dp[pos][cnt];
if ((n + 1 - pos) * n < cnt) return 0;
long long p = m / n;
bool b = (pos <= m % n);
if (b) {
for (int i = 0; i <= n; i++) {
dp[pos][cnt] = add(mult(solve(pos + 1, cnt - i), arr2[i]), dp[pos][cnt]);
}
} else {
for (int i = 0; i <= n; i++) {
dp[pos][cnt] = add(mult(solve(pos + 1, cnt - i), arr1[i]), dp[pos][cnt]);
}
}
done[pos][cnt] = true;
return dp[pos][cnt];
}
int main() {
scanf("%d %I64d %d", &n, &m, &k);
fact[0] = 1, inv[0] = 1;
long long p = m / n;
for (int i = 1; i < N; i++) {
fact[i] = mult(fact[i - 1], i);
inv[i] = powmod(fact[i], mod - 2);
}
for (int i = 0; i <= n; i++) {
arr1[i] = powmod(ncr(n, i), p);
arr2[i] = powmod(ncr(n, i), p + 1);
}
memset(dp, 0, sizeof(dp));
int ans = solve(1, k);
printf("%d\n", ans);
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
Once upon a time in the galaxy of far, far away...
Darth Wader found out the location of a rebels' base. Now he is going to destroy the base (and the whole planet that the base is located at), using the Death Star.
When the rebels learnt that the Death Star was coming, they decided to use their new secret weapon — space mines. Let's describe a space mine's build.
Each space mine is shaped like a ball (we'll call it the mine body) of a certain radius r with the center in the point O. Several spikes protrude from the center. Each spike can be represented as a segment, connecting the center of the mine with some point P, such that <image> (transporting long-spiked mines is problematic), where |OP| is the length of the segment connecting O and P. It is convenient to describe the point P by a vector p such that P = O + p.
The Death Star is shaped like a ball with the radius of R (R exceeds any mine's radius). It moves at a constant speed along the v vector at the speed equal to |v|. At the moment the rebels noticed the Star of Death, it was located in the point A.
The rebels located n space mines along the Death Star's way. You may regard the mines as being idle. The Death Star does not know about the mines' existence and cannot notice them, which is why it doesn't change the direction of its movement. As soon as the Star of Death touched the mine (its body or one of the spikes), the mine bursts and destroys the Star of Death. A touching is the situation when there is a point in space which belongs both to the mine and to the Death Star. It is considered that Death Star will not be destroyed if it can move infinitely long time without touching the mines.
Help the rebels determine whether they will succeed in destroying the Death Star using space mines or not. If they will succeed, determine the moment of time when it will happen (starting from the moment the Death Star was noticed).
Input
The first input data line contains 7 integers Ax, Ay, Az, vx, vy, vz, R. They are the Death Star's initial position, the direction of its movement, and its radius ( - 10 ≤ vx, vy, vz ≤ 10, |v| > 0, 0 < R ≤ 100).
The second line contains an integer n, which is the number of mines (1 ≤ n ≤ 100). Then follow n data blocks, the i-th of them describes the i-th mine.
The first line of each block contains 5 integers Oix, Oiy, Oiz, ri, mi, which are the coordinates of the mine centre, the radius of its body and the number of spikes (0 < ri < 100, 0 ≤ mi ≤ 10). Then follow mi lines, describing the spikes of the i-th mine, where the j-th of them describes the i-th spike and contains 3 integers pijx, pijy, pijz — the coordinates of the vector where the given spike is directed (<image>).
The coordinates of the mines' centers and the center of the Death Star are integers, their absolute value does not exceed 10000. It is guaranteed that R > ri for any 1 ≤ i ≤ n. For any mines i ≠ j the following inequality if fulfilled: <image>. Initially the Death Star and the mines do not have common points.
Output
If the rebels will succeed in stopping the Death Star using space mines, print the time from the moment the Death Star was noticed to the blast.
If the Death Star will not touch a mine, print "-1" (without quotes).
For the answer the absolute or relative error of 10 - 6 is acceptable.
Examples
Input
0 0 0 1 0 0 5
2
10 8 0 2 2
0 -3 0
2 2 0
20 0 0 4 3
2 4 0
-4 3 0
1 -5 0
Output
10.0000000000
Input
8 8 4 4 4 2 6
1
-2 -2 -1 3 0
Output
-1
Input
30 30 2 1 2 1 20
3
0 0 40 5 1
1 4 4
-10 -40 -5 7 0
100 200 95 8 1
-10 0 0
Output
74.6757620881
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
class vec {
public:
long double x, y, z;
vec operator-(const vec& rhs) {
vec res;
res.x = x - rhs.x;
res.y = y - rhs.y;
res.z = z - rhs.z;
return res;
}
vec operator+(const vec& rhs) {
vec res;
res.x = x + rhs.x;
res.y = y + rhs.y;
res.z = z + rhs.z;
return res;
}
vec operator*(long double t) {
vec res = *this;
res.x *= t;
res.y *= t;
res.z *= t;
return res;
}
};
long double len(const vec& v) {
return sqrt(v.x * v.x + v.y * v.y + v.z * v.z);
}
long double len2(const vec& v) { return v.x * v.x + v.y * v.y + v.z * v.z; }
long double dot(const vec& a, const vec& b) {
return a.x * b.x + a.y * b.y + a.z * b.z;
}
long double cross(const vec& a, const vec& b) {
vec r;
r.x = a.y * b.z - b.y * a.z;
r.y = a.z * b.x - b.z * a.x;
r.z = a.x * b.y - b.x * a.y;
return len(r);
}
istream& operator>>(istream& s, vec& v) {
s >> v.x >> v.y >> v.z;
return s;
}
ostream& operator<<(ostream& s, vec& v) {
s << "[" << v.x << ", " << v.y << ", " << v.z << "]";
return s;
}
long double calc_t(vec p, vec v, long double R) {
if (dot(p, v) < 0) return 1E+100;
long double t = dot(p, v) / len2(v);
if (len2(v * t - p) > R * R) return 1E+100;
long double l = 0;
long double r = t;
while (r - l > 1E-10) {
t = (r + l) / 2;
if (len2(v * t - p) > R * R)
l = t;
else
r = t;
}
vec x = (v * ((r + l) / 2) - p);
return (r + l) / 2;
}
int main() {
vec A, v;
long double R;
cin >> A >> v >> R;
int N;
cin >> N;
long double res = 1E+100;
for (int i = 0; i < N; i++) {
int m;
long double r;
vec C;
cin >> C >> r >> m;
res = min(res, calc_t(C - A, v, R + r));
for (int j = 0; j < m; j++) {
vec p;
cin >> p;
res = min(res, calc_t(C + p - A, v, R));
}
}
if (res == 1E+100)
cout << -1 << endl;
else
cout << fixed << setprecision(10) << res << endl;
return 0;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
Nathan O. Davis is trying to capture a game and struggling to get a very rare item. This rare item can be obtained by arranging special patterns in a row on a casino slot machine. The slot machine has N reels, and pressing the button once stops the currently rotating leftmost reel. Therefore, you need to press the button N times to get this rare item. Also, in order to stop with a special pattern, it is necessary to press the button at a certain timing. However, the timing of pressing this button was very severe, so I was in trouble because it didn't go well. Therefore, Nathan decided to analyze the game while checking the memory value during the game using the memory viewer.
As a result of Nathan's analysis, in order to stop the reel with that special pattern, the "random number" written at address 007E0D1F in the memory must have a specific value when the button is pressed. I found out. It was also found that the value of the random number changes every frame by the linear congruential method, and whether or not the button is pressed is judged once every frame. Here, the linear congruential method is one of the methods for generating pseudo-random numbers, and the value is determined by the following formula.
x'= (A x x + B) mod C
Here, x is the value of the current random number, x'is the value of the next random number, and A, B, and C are some constants. Also, y mod z represents the remainder when y is divided by z.
For example, suppose a slot machine with two reels has A = 5, B = 7, C = 11 and the first "random number" value is 10. And, the condition for stopping the reel with a special pattern is that the reel on the left side is 2 and the reel on the right side is 4. At this time, the value of the random number in the first frame is (5 × 10 + 7) mod 11 = 2, so if you press the button in the first frame, the reel on the left side will stop with a special pattern. Since the value of the random number in the second frame that follows is (5 x 2 + 7) mod 11 = 6, the reel on the right side does not stop with a special pattern even if the button is pressed in the second frame. In the following 3rd frame, the random number value becomes (5 x 6 + 7) mod 11 = 4, so if you press the button in the 3rd frame, the reel on the right side will stop with a special pattern. Therefore, all reels can be stopped with a special pattern in a minimum of 3 frames, and rare items can be obtained.
Your job is to help Nathan get a rare item by writing a program that asks how many frames in the shortest frame all reels can be stopped with a special pattern. ..
Input
The input consists of multiple datasets. Each dataset is given in the following format.
> N A B C X
> Y1 Y2 ... YN
The first row contains five integers N (1 ≤ N ≤ 100), A, B (0 ≤ A, B ≤ 10,000), C (1 ≤ C ≤ 10,000), and X (0 ≤ X <C), respectively. It is given separated by two whitespace characters. Here, X represents the value of the first random number. On the following line, N integers Y1, Y2, ..., YN (0 ≤ Yi ≤ 10,000) are given, separated by a single space character. These represent the conditions for stopping the reel with a specific pattern, and the i-th number Yi is the random number value Yi to stop the i-th reel from the left with a special pattern. It means that there must be.
The end of the input is indicated by a single line containing five zeros separated by blanks.
Output
For each dataset, output the shortest number of frames required to stop at a special pattern on one line. If it cannot be stopped within 10,000 frames, output -1 instead of the number of frames. The output must not contain extra blanks or line breaks.
Sample Input
1 5 7 11 10
Ten
2 5 7 11 10
twenty four
2 1 1 256 0
128 255
2 0 0 1 0
1 2 3 4 5 6 7 8
2 1 1 100 0
99 98
2 1 1 100 0
99 99
2 1 1 10000 0
Ten
2 1 1 10000 0
twenty one
0 0 0 0 0
Output for the Sample Input
0
3
255
-1
198
199
10000
-1
Example
Input
1 5 7 11 10
10
2 5 7 11 10
2 4
2 1 1 256 0
128 255
2 0 0 1 0
1234 5678
2 1 1 100 0
99 98
2 1 1 100 0
99 99
2 1 1 10000 0
1 0
2 1 1 10000 0
2 1
0 0 0 0 0
Output
0
3
255
-1
198
199
10000
-1
### Response
```cpp
#include <iostream>
using namespace std;
int main(){
int n,a,b,c,x,sum;
int stop[101];
while(cin>>n>>a>>b>>c>>x,n||a||b||c||x){
sum = 0;
for(int i=0;i<n;i++) cin >> stop[i];
for(int i=0,j=0;i<n;i++){
while(true){
if(stop[i] == x) break;
j++;
x = (a * x + b) % c;
if(sum + j > 10000){ sum = -1; goto exit; }
}
sum += j;
x = (a * x + b) % c; j=1;
}
exit:
cout << sum << endl;
}
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
You are given two integers b and w. You have a chessboard of size 10^9 × 10^9 with the top left cell at (1; 1), the cell (1; 1) is painted white.
Your task is to find a connected component on this chessboard that contains exactly b black cells and exactly w white cells. Two cells are called connected if they share a side (i.e. for the cell (x, y) there are at most four connected cells: (x - 1, y), (x + 1, y), (x, y - 1), (x, y + 1)). A set of cells is called a connected component if for every pair of cells C_1 and C_2 from this set, there exists a sequence of cells c_1, c_2, ..., c_k such that c_1 = C_1, c_k = C_2, all c_i from 1 to k are belong to this set of cells and for every i ∈ [1, k - 1], cells c_i and c_{i + 1} are connected.
Obviously, it can be impossible to find such component. In this case print "NO". Otherwise, print "YES" and any suitable connected component.
You have to answer q independent queries.
Input
The first line of the input contains one integer q (1 ≤ q ≤ 10^5) — the number of queries. Then q queries follow.
The only line of the query contains two integers b and w (1 ≤ b, w ≤ 10^5) — the number of black cells required and the number of white cells required.
It is guaranteed that the sum of numbers of cells does not exceed 2 ⋅ 10^5 (∑ w + ∑ b ≤ 2 ⋅ 10^5).
Output
For each query, print the answer to it.
If it is impossible to find the required component, print "NO" on the first line.
Otherwise, print "YES" on the first line. In the next b + w lines print coordinates of cells of your component in any order. There should be exactly b black cells and w white cells in your answer. The printed component should be connected.
If there are several answers, you can print any. All coordinates in the answer should be in the range [1; 10^9].
Example
Input
3
1 1
1 4
2 5
Output
YES
2 2
1 2
YES
2 3
1 3
3 3
2 2
2 4
YES
2 3
2 4
2 5
1 3
1 5
3 3
3 5
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int q, b, w;
int main() {
scanf("%d", &q);
for (int i = 1; i <= q; ++i) {
int x = 2;
scanf("%d%d", &b, &w);
swap(b, w);
if (b > w) swap(b, w), x = 3;
if (b * 3 + 1 < w) {
printf("NO\n");
continue;
}
printf("YES\n");
for (int i = 1; i <= b; ++i) printf("%d %d\n", x, i * 2);
for (int i = 1; i <= b; ++i) {
printf("%d %d\n", x, i * 2 - 1);
--w;
}
if (w > 0) {
printf("%d %d\n", x, b * 2 + 1);
w--;
}
if (w > 0) {
for (int i = 1; i <= b && w > 0; ++i, w--)
printf("%d %d\n", x + 1, i * 2);
}
if (w > 0) {
for (int i = 1; i <= b && w > 0; ++i, --w)
printf("%d %d\n", x - 1, i * 2);
}
}
return 0;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
Let's call some square matrix with integer values in its cells palindromic if it doesn't change after the order of rows is reversed and it doesn't change after the order of columns is reversed.
For example, the following matrices are palindromic:
<image>
The following matrices are not palindromic because they change after the order of rows is reversed:
<image>
The following matrices are not palindromic because they change after the order of columns is reversed:
<image>
You are given n^2 integers. Put them into a matrix of n rows and n columns so that each number is used exactly once, each cell contains exactly one number and the resulting matrix is palindromic. If there are multiple answers, print any. If there is no solution, print "NO".
Input
The first line contains one integer n (1 ≤ n ≤ 20).
The second line contains n^2 integers a_1, a_2, ..., a_{n^2} (1 ≤ a_i ≤ 1000) — the numbers to put into a matrix of n rows and n columns.
Output
If it is possible to put all of the n^2 numbers into a matrix of n rows and n columns so that each number is used exactly once, each cell contains exactly one number and the resulting matrix is palindromic, then print "YES". Then print n lines with n space-separated numbers — the resulting matrix.
If it's impossible to construct any matrix, then print "NO".
You can print each letter in any case (upper or lower). For example, "YeS", "no" and "yES" are all acceptable.
Examples
Input
4
1 8 8 1 2 2 2 2 2 2 2 2 1 8 8 1
Output
YES
1 2 2 1
8 2 2 8
8 2 2 8
1 2 2 1
Input
3
1 1 1 1 1 3 3 3 3
Output
YES
1 3 1
3 1 3
1 3 1
Input
4
1 2 1 9 8 4 3 8 8 3 4 8 9 2 1 1
Output
NO
Input
1
10
Output
YES
10
Note
Note that there exist multiple answers for the first two examples.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, a[405], ans[25][25], maxx, num[1005];
struct node {
int num, id;
};
queue<int> q[1005];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n * n; i++) {
scanf("%d", &a[i]);
num[a[i]]++;
maxx = max(maxx, a[i]);
}
for (int i = 1; i <= maxx; i++)
if (num[i]) q[num[i]].push(i);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (ans[i][j]) continue;
int x1 = i, y = j;
int x2 = i, y2 = n - j + 1;
int x3 = n - i + 1, y3 = j;
int x4 = n - i + 1, y4 = n - j + 1;
if (x1 == x2 && y == y2 && x3 == x1 && y3 == y) {
int f = 0;
for (int k = 1; k <= n * n; k++) {
if (q[k].size()) {
f = 1;
int t = q[k].front();
q[k].pop(), num[t]--;
q[num[t]].push(t);
ans[i][j] = t;
break;
}
}
if (!f) {
printf("NO\n");
return 0;
}
} else if (x1 == x2 && y == y2) {
int f = 0;
for (int k = 2; k <= n * n; k++) {
if (q[k].size()) {
f = 1;
int t = q[k].front();
q[k].pop(), num[t] -= 2;
q[num[t]].push(t);
ans[i][j] = t, ans[x3][y3] = t;
break;
}
}
if (!f) {
printf("NO\n");
return 0;
}
} else if (x1 == x3 && y == y3) {
int f = 0;
for (int k = 2; k <= n * n; k++) {
if (q[k].size()) {
f = 1;
int t = q[k].front();
q[k].pop(), num[t] -= 2;
q[num[t]].push(t);
ans[i][j] = t, ans[x2][y2] = t;
break;
}
}
if (!f) {
printf("NO\n");
return 0;
}
} else {
int f = 0;
for (int k = 4; k <= n * n; k++) {
if (q[k].size()) {
f = 1;
int t = q[k].front();
q[k].pop(), num[t] -= 4;
q[num[t]].push(t);
ans[i][j] = t, ans[x2][y2] = t, ans[x3][y3] = t, ans[x4][y4] = t;
break;
}
}
if (!f) {
printf("NO\n");
return 0;
}
}
}
}
printf("YES\n");
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
printf("%d ", ans[i][j]);
}
printf("\n");
}
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
We have a string S consisting of uppercase English letters. Additionally, an integer N will be given.
Shift each character of S by N in alphabetical order (see below), and print the resulting string.
We assume that `A` follows `Z`. For example, shifting `A` by 2 results in `C` (`A` \to `B` \to `C`), and shifting `Y` by 3 results in `B` (`Y` \to `Z` \to `A` \to `B`).
Constraints
* 0 \leq N \leq 26
* 1 \leq |S| \leq 10^4
* S consists of uppercase English letters.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the string resulting from shifting each character of S by N in alphabetical order.
Examples
Input
2
ABCXYZ
Output
CDEZAB
Input
0
ABCXYZ
Output
ABCXYZ
Input
13
ABCDEFGHIJKLMNOPQRSTUVWXYZ
Output
NOPQRSTUVWXYZABCDEFGHIJKLM
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main() {
int n,i;
string s;
cin>>n>>s;
for(i=0;i<s.size();i++)
{
cout<<char('A'+(s[i]+n-'A')%26);
}
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
Alice has a string consisting of characters 'A', 'B' and 'C'. Bob can use the following transitions on any substring of our string in any order any number of times:
* A <image> BC
* B <image> AC
* C <image> AB
* AAA <image> empty string
Note that a substring is one or more consecutive characters. For given queries, determine whether it is possible to obtain the target string from source.
Input
The first line contains a string S (1 ≤ |S| ≤ 105). The second line contains a string T (1 ≤ |T| ≤ 105), each of these strings consists only of uppercase English letters 'A', 'B' and 'C'.
The third line contains the number of queries Q (1 ≤ Q ≤ 105).
The following Q lines describe queries. The i-th of these lines contains four space separated integers ai, bi, ci, di. These represent the i-th query: is it possible to create T[ci..di] from S[ai..bi] by applying the above transitions finite amount of times?
Here, U[x..y] is a substring of U that begins at index x (indexed from 1) and ends at index y. In particular, U[1..|U|] is the whole string U.
It is guaranteed that 1 ≤ a ≤ b ≤ |S| and 1 ≤ c ≤ d ≤ |T|.
Output
Print a string of Q characters, where the i-th character is '1' if the answer to the i-th query is positive, and '0' otherwise.
Example
Input
AABCCBAAB
ABCB
5
1 3 1 2
2 2 2 4
7 9 1 1
3 4 2 3
4 5 1 3
Output
10011
Note
In the first query we can achieve the result, for instance, by using transitions <image>.
The third query asks for changing AAB to A — but in this case we are not able to get rid of the character 'B'.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int sbc[N], sras[N];
int tbc[N], tras[N];
int main() {
string s, t;
cin >> s >> t;
for (int i = 0; i < s.size(); i++) {
sbc[i + 1] = sbc[i] + (s[i] == 'B' or s[i] == 'C');
if (s[i] == 'A') sras[i + 1] = sras[i] + 1;
}
for (int i = 0; i < t.size(); i++) {
tbc[i + 1] = tbc[i] + (t[i] == 'B' or t[i] == 'C');
if (t[i] == 'A') tras[i + 1] = tras[i] + 1;
}
int q;
cin >> q;
while (q--) {
int i1, j1, i2, j2;
cin >> i1 >> j1 >> i2 >> j2;
i1--, i2--;
int ra1 = min(sras[j1], j1 - i1);
int ra2 = min(tras[j2], j2 - i2);
int bc1 = sbc[j1] - sbc[i1];
int bc2 = tbc[j2] - tbc[i2];
if (ra2 % 3 != ra1 % 3) bc1 += 2;
if (ra2 > ra1 or ra2 == ra1 and bc1 == 0 and bc2 > 0)
cout << 0;
else if (bc1 > bc2 or bc1 % 2 != bc2 % 2)
cout << 0;
else
cout << 1;
}
cout << endl;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
This is the easier version of the problem. In this version 1 ≤ n, m ≤ 100. You can hack this problem only if you solve and lock both problems.
You are given a sequence of integers a=[a_1,a_2,...,a_n] of length n. Its subsequence is obtained by removing zero or more elements from the sequence a (they do not necessarily go consecutively). For example, for the sequence a=[11,20,11,33,11,20,11]:
* [11,20,11,33,11,20,11], [11,20,11,33,11,20], [11,11,11,11], [20], [33,20] are subsequences (these are just some of the long list);
* [40], [33,33], [33,20,20], [20,20,11,11] are not subsequences.
Suppose that an additional non-negative integer k (1 ≤ k ≤ n) is given, then the subsequence is called optimal if:
* it has a length of k and the sum of its elements is the maximum possible among all subsequences of length k;
* and among all subsequences of length k that satisfy the previous item, it is lexicographically minimal.
Recall that the sequence b=[b_1, b_2, ..., b_k] is lexicographically smaller than the sequence c=[c_1, c_2, ..., c_k] if the first element (from the left) in which they differ less in the sequence b than in c. Formally: there exists t (1 ≤ t ≤ k) such that b_1=c_1, b_2=c_2, ..., b_{t-1}=c_{t-1} and at the same time b_t<c_t. For example:
* [10, 20, 20] lexicographically less than [10, 21, 1],
* [7, 99, 99] is lexicographically less than [10, 21, 1],
* [10, 21, 0] is lexicographically less than [10, 21, 1].
You are given a sequence of a=[a_1,a_2,...,a_n] and m requests, each consisting of two numbers k_j and pos_j (1 ≤ k ≤ n, 1 ≤ pos_j ≤ k_j). For each query, print the value that is in the index pos_j of the optimal subsequence of the given sequence a for k=k_j.
For example, if n=4, a=[10,20,30,20], k_j=2, then the optimal subsequence is [20,30] — it is the minimum lexicographically among all subsequences of length 2 with the maximum total sum of items. Thus, the answer to the request k_j=2, pos_j=1 is the number 20, and the answer to the request k_j=2, pos_j=2 is the number 30.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the length of the sequence a.
The second line contains elements of the sequence a: integer numbers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9).
The third line contains an integer m (1 ≤ m ≤ 100) — the number of requests.
The following m lines contain pairs of integers k_j and pos_j (1 ≤ k ≤ n, 1 ≤ pos_j ≤ k_j) — the requests.
Output
Print m integers r_1, r_2, ..., r_m (1 ≤ r_j ≤ 10^9) one per line: answers to the requests in the order they appear in the input. The value of r_j should be equal to the value contained in the position pos_j of the optimal subsequence for k=k_j.
Examples
Input
3
10 20 10
6
1 1
2 1
2 2
3 1
3 2
3 3
Output
20
10
20
10
20
10
Input
7
1 2 1 3 1 2 1
9
2 1
2 2
3 1
3 2
3 3
1 1
7 1
7 7
7 4
Output
2
3
2
3
2
3
1
1
3
Note
In the first example, for a=[10,20,10] the optimal subsequences are:
* for k=1: [20],
* for k=2: [10,20],
* for k=3: [10,20,10].
### 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, m, tmp_int, k, pos;
cin >> n;
vector<int> a;
vector<pair<int, int>> b;
for (int i = 0; i < n; ++i) {
cin >> tmp_int;
a.push_back(tmp_int);
b.emplace_back(tmp_int, -1 * i);
}
cin >> m;
sort((b).begin(), (b).end());
for (int req = 0; req < m; ++req) {
cin >> k >> pos;
vector<pair<int, int>> c;
for (int i = n - k; i < n; ++i) {
c.emplace_back(-1 * b[i].second, b[i].first);
}
sort((c).begin(), (c).end());
cout << c[pos - 1].second << '\n';
}
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
Example
Input
2 10 6
4 4 E
6 4 W
Output
2
### Response
```cpp
#include <iostream>
#include <string>
#include <vector>
#include <queue>
#include <algorithm>
#include <tuple>
using namespace std;
typedef pair<int, int> pii;
static const int INF = 1000000000;
int main(){
ios_base::sync_with_stdio(false);
int n, w, h;
cin >> n >> w >> h;
vector<pii> ranges;
for(int i = 0; i < n; ++i){
int x, y;
string f;
cin >> x >> y >> f;
const int hw2 = h + w + h + w;
const int lu = y + x;
const int ru = h + x + (h - y);
const int rd = h + w + (h - y) + (w - x);
const int ld = h + w + h + (w - x) + y;
int lo = 0, hi = 0;
if(f[0] == 'N'){
lo = lu; hi = ru;
}else if(f[0] == 'E'){
lo = ru; hi = rd;
}else if(f[0] == 'S'){
lo = rd; hi = ld;
}else if(f[0] == 'W'){
lo = ld; hi = lu + hw2;
}
if(lo >= hw2){
lo -= hw2;
hi -= hw2;
}
ranges.emplace_back(lo, hi);
ranges.emplace_back(lo + hw2, hi + hw2);
}
sort(ranges.begin(), ranges.end());
int answer = INF;
for(int i = 0; i < n; ++i){
const int hw2 = (h + w) * 2;
vector<pii> r(ranges.begin() + i, ranges.begin() + i + n);
sort(r.begin(), r.end(), [](const pii &a, const pii &b){
return (a.second == b.second) ? (a.first < b.first) : (a.second < b.second);
});
int count = 1, last = r[0].second;
for(int j = 0; j < n; ++j){
if(r[j].first <= last){ continue; }
if(r[j].second >= r[0].second + hw2){ continue; }
++count;
last = r[j].second;
}
answer = min(answer, count);
}
cout << answer << endl;
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
Each student eagerly awaits the day he would pass the exams successfully. Thus, Vasya was ready to celebrate, but, alas, he didn't pass it. However, many of Vasya's fellow students from the same group were more successful and celebrated after the exam.
Some of them celebrated in the BugDonalds restaurant, some of them — in the BeaverKing restaurant, the most successful ones were fast enough to celebrate in both of restaurants. Students which didn't pass the exam didn't celebrate in any of those restaurants and elected to stay home to prepare for their reexamination. However, this quickly bored Vasya and he started checking celebration photos on the Kilogramm. He found out that, in total, BugDonalds was visited by A students, BeaverKing — by B students and C students visited both restaurants. Vasya also knows that there are N students in his group.
Based on this info, Vasya wants to determine either if his data contradicts itself or, if it doesn't, how many students in his group didn't pass the exam. Can you help him so he won't waste his valuable preparation time?
Input
The first line contains four integers — A, B, C and N (0 ≤ A, B, C, N ≤ 100).
Output
If a distribution of N students exists in which A students visited BugDonalds, B — BeaverKing, C — both of the restaurants and at least one student is left home (it is known that Vasya didn't pass the exam and stayed at home), output one integer — amount of students (including Vasya) who did not pass the exam.
If such a distribution does not exist and Vasya made a mistake while determining the numbers A, B, C or N (as in samples 2 and 3), output -1.
Examples
Input
10 10 5 20
Output
5
Input
2 2 0 4
Output
-1
Input
2 2 2 1
Output
-1
Note
The first sample describes following situation: 5 only visited BugDonalds, 5 students only visited BeaverKing, 5 visited both of them and 5 students (including Vasya) didn't pass the exam.
In the second sample 2 students only visited BugDonalds and 2 only visited BeaverKing, but that means all 4 students in group passed the exam which contradicts the fact that Vasya didn't pass meaning that this situation is impossible.
The third sample describes a situation where 2 students visited BugDonalds but the group has only 1 which makes it clearly impossible.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, n;
cin >> a >> b >> c >> n;
if ((a + b - c) >= n || a < c || b < c)
cout << "-1" << endl;
else
cout << n - a - b + c << endl;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
In distant future on Earth day lasts for n hours and that's why there are n timezones. Local times in adjacent timezones differ by one hour. For describing local time, hours numbers from 1 to n are used, i.e. there is no time "0 hours", instead of it "n hours" is used. When local time in the 1-st timezone is 1 hour, local time in the i-th timezone is i hours.
Some online programming contests platform wants to conduct a contest that lasts for an hour in such a way that its beginning coincides with beginning of some hour (in all time zones). The platform knows, that there are ai people from i-th timezone who want to participate in the contest. Each person will participate if and only if the contest starts no earlier than s hours 00 minutes local time and ends not later than f hours 00 minutes local time. Values s and f are equal for all time zones. If the contest starts at f hours 00 minutes local time, the person won't participate in it.
Help platform select such an hour, that the number of people who will participate in the contest is maximum.
Input
The first line contains a single integer n (2 ≤ n ≤ 100 000) — the number of hours in day.
The second line contains n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 10 000), where ai is the number of people in the i-th timezone who want to participate in the contest.
The third line contains two space-separated integers s and f (1 ≤ s < f ≤ n).
Output
Output a single integer — the time of the beginning of the contest (in the first timezone local time), such that the number of participants will be maximum possible. If there are many answers, output the smallest among them.
Examples
Input
3
1 2 3
1 3
Output
3
Input
5
1 2 3 4 1
1 3
Output
4
Note
In the first example, it's optimal to start competition at 3 hours (in first timezone). In this case, it will be 1 hour in the second timezone and 2 hours in the third timezone. Only one person from the first timezone won't participate.
In second example only people from the third and the fourth timezones will participate.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 2 * 1e5 + 5;
int a[N], sum[N], n, s, f;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", a + i);
scanf("%d%d", &s, &f);
for (int i = n; i < n + n; i++) a[i] = a[i - n];
for (int i = 0; i < n + n; i++) {
if (!i)
sum[i] = a[i];
else
sum[i] = sum[i - 1] + a[i];
}
int len = f - s;
int mx = -1, ans = 1;
int t = s;
for (int i = 0; i < n; i++) {
int cnt = i ? sum[i + len - 1] - sum[i - 1] : sum[i + len - 1];
if (cnt > mx || cnt == mx && t < ans) {
mx = cnt;
ans = t;
}
t--;
if (t == 0) t = n;
}
printf("%d\n", ans);
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
You're given a tree with n vertices. The color of the i-th vertex is h_{i}.
The value of the tree is defined as ∑_{h_{i} = h_{j}, 1 ≤ i < j ≤ n}{dis(i,j)}, where dis(i,j) is the number of edges on the shortest path between i and j.
The color of each vertex is lost, you only remember that h_{i} can be any integer from [l_{i}, r_{i}](inclusive). You want to calculate the sum of values of all trees meeting these conditions modulo 10^9 + 7 (the set of edges is fixed, but each color is unknown, so there are ∏_{i = 1}^{n} (r_{i} - l_{i} + 1) different trees).
Input
The first line contains one integer n (2 ≤ n ≤ 10^5) — the number of vertices.
Then n lines follow, each line contains two integers l_i and r_i (1 ≤ l_i ≤ r_i ≤ 10^5) denoting the range of possible colors of vertex i.
Then n - 1 lines follow, each containing two integers u and v (1 ≤ u, v ≤ n, u ≠ v) denoting an edge of the tree. It is guaranteed that these edges form a tree.
Output
Print one integer — the sum of values of all possible trees, taken modulo 10^9 + 7.
Example
Input
4
1 1
1 2
1 1
1 2
1 2
1 3
3 4
Output
22
Note
In the first example there are four different ways to color the tree (so, there are four different trees):
* a tree with vertices colored as follows: { 1,1,1,1 }. The value of this tree is dis(1,2)+dis(1,3)+dis(1,4)+dis(2,3)+dis(2,4)+dis(3,4) = 10;
* a tree with vertices colored as follows: { 1,2,1,1 }. The value of this tree is dis(1,3)+dis(1,4)+dis(3,4)=4;
* a tree with vertices colored as follows: { 1,1,1,2 }. The value of this tree is dis(1,2)+dis(1,3)+dis(2,3)=4;
* a tree with vertices colored as follows: { 1,2,1,2 }. The value of this tree is dis(1,3)+dis(2,4)=4.
Overall the sum of all values is 10+4+4+4=22.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, ans, gsub, all = 1;
int l[100005], r[100005], sub[100005], inv[100005], c[100005], f[100005],
F[100005];
vector<int> v[100005];
int mul(int x, int y) { return (long long)x * y % 1000000007; }
int add(int x, int y) {
x += y;
if (x >= 1000000007) x -= 1000000007;
if (x < 0) x += 1000000007;
return x;
}
int fe(int x, int y) {
if (y == 0) return 1;
if (y & 1) return mul(fe(x, y ^ 1), x);
int res = fe(x, y >> 1);
return mul(res, res);
}
int get(int x) {
int res = 0;
for (int i = x; i >= 1; i -= i & -i) {
res = add(res, add(c[i], mul(x, F[i])));
}
return res;
}
void upf(int x, int val) {
for (int i = x; i <= (100005 - 5); i += i & -i) F[i] = add(F[i], val);
}
void upc(int x, int val) {
for (int i = x; i <= (100005 - 5); i += i & -i) c[i] = add(c[i], val);
}
void up(int x, int y, int val) {
upc(x, mul(x - 1, -val));
upc(y + 1, mul(y, val));
upf(x, val);
upf(y + 1, -val);
}
void dfs2(int node, int dad, int dep, int upv) {
up(l[node], r[node], mul(dep * upv, inv[node]));
for (int i : v[node])
if (!f[i] && i != dad) dfs2(i, node, dep + 1, upv);
}
void dfs1(int node, int dad) {
ans = add(ans, mul(add(get(r[node]), -get(l[node] - 1)), inv[node]));
for (int i : v[node])
if (!f[i] && i != dad) dfs1(i, node);
}
void count(int cnt, int ok) {
for (int i : v[cnt]) {
if (!f[i]) dfs1(i, 0), dfs2(i, 0, 1, 1);
}
if (ok) ans = add(ans, mul(add(get(r[cnt]), -get(l[cnt] - 1)), inv[cnt]));
for (int i : v[cnt]) {
if (!f[i]) dfs2(i, 0, 1, -1);
}
}
int fcnt(int node, int dad) {
for (int i : v[node])
if (!f[i] && i != dad && sub[i] > gsub / 2) return fcnt(i, node);
return node;
}
void fsubs(int node, int dad) {
sub[node] = 1;
for (int i : v[node])
if (!f[i] && i != dad) fsubs(i, node), sub[node] += sub[i];
}
void solve(int node) {
fsubs(node, 0);
gsub = sub[node];
int cnt = fcnt(node, 0);
f[cnt] = 1;
count(cnt, 0);
reverse(v[cnt].begin(), v[cnt].end());
count(cnt, 1);
for (int i : v[cnt]) {
if (!f[i]) solve(i);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d %d", l + i, r + i);
inv[i] = fe(r[i] - l[i] + 1, 1000000007 - 2);
all = mul(all, r[i] - l[i] + 1);
}
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d %d", &x, &y);
v[x].push_back(y);
v[y].push_back(x);
}
solve(1);
printf("%d", mul(ans, all));
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
n ants are on a circle of length m. An ant travels one unit of distance per one unit of time. Initially, the ant number i is located at the position si and is facing in the direction di (which is either L or R). Positions are numbered in counterclockwise order starting from some point. Positions of the all ants are distinct.
All the ants move simultaneously, and whenever two ants touch, they will both switch their directions. Note that it is possible for an ant to move in some direction for a half of a unit of time and in opposite direction for another half of a unit of time.
Print the positions of the ants after t time units.
Input
The first line contains three integers n, m and t (2 ≤ n ≤ 3·105, 2 ≤ m ≤ 109, 0 ≤ t ≤ 1018) — the number of ants, the length of the circle and the number of time units.
Each of the next n lines contains integer si and symbol di (1 ≤ si ≤ m and di is either L or R) — the position and the direction of the i-th ant at the start. The directions L and R corresponds to the clockwise and counterclockwise directions, respectively.
It is guaranteed that all positions si are distinct.
Output
Print n integers xj — the position of the j-th ant after t units of time. The ants are numbered from 1 to n in order of their appearing in input.
Examples
Input
2 4 8
1 R
3 L
Output
1 3
Input
4 8 6
6 R
5 L
1 R
8 L
Output
7 4 2 7
Input
4 8 2
1 R
5 L
6 L
8 R
Output
3 3 4 2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long a = 0, b = getchar(), c = 1;
while (!isdigit(b)) c = b == '-' ? -1 : 1, b = getchar();
while (isdigit(b)) a = a * 10 + b - '0', b = getchar();
return a * c;
}
const int N = 3e5 + 5;
long long n, m, t, a[N], id[N], b[N], ans[N];
bool cmp(int x, int y) { return a[x] < a[y]; }
int main() {
n = read(), m = read(), t = read();
for (int i = 0; i < n; i++) {
a[i] = read() - 1, id[i] = i;
char ch;
scanf("%c", &ch);
b[i] = ch == 'L' ? -1 : 1;
}
sort(id, id + n, cmp);
int x = 0;
for (int i = 0; i < n; i++) {
if (b[i] == 1)
x += (a[i] + t) / m % n;
else
x += (a[i] - t - m + 1) / m % n;
x = (x % n + n) % n;
a[i] = a[i] + t % m * b[i];
a[i] = (a[i] % m + m) % m;
}
sort(a, a + n);
for (int i = 0; i < n; i++) ans[id[(i + n - x) % n]] = a[i] + 1;
for (int i = 0; i < n; i++) printf("%lld ", ans[i]);
return 0;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
The hero of our story, Valera, and his best friend Arcady are still in school, and therefore they spend all the free time playing turn-based strategy "GAGA: Go And Go Again". The gameplay is as follows.
There are two armies on the playing field each of which consists of n men (n is always even). The current player specifies for each of her soldiers an enemy's soldier he will shoot (a target) and then all the player's soldiers shot simultaneously. This is a game world, and so each soldier shoots perfectly, that is he absolutely always hits the specified target. If an enemy soldier is hit, he will surely die. It may happen that several soldiers had been indicated the same target. Killed soldiers do not participate in the game anymore.
The game "GAGA" consists of three steps: first Valera makes a move, then Arcady, then Valera again and the game ends.
You are asked to calculate the maximum total number of soldiers that may be killed during the game.
Input
The input data consist of a single integer n (2 ≤ n ≤ 108, n is even). Please note that before the game starts there are 2n soldiers on the fields.
Output
Print a single number — a maximum total number of soldiers that could be killed in the course of the game in three turns.
Examples
Input
2
Output
3
Input
4
Output
6
Note
The first sample test:
1) Valera's soldiers 1 and 2 shoot at Arcady's soldier 1.
2) Arcady's soldier 2 shoots at Valera's soldier 1.
3) Valera's soldier 1 shoots at Arcady's soldier 2.
There are 3 soldiers killed in total: Valera's soldier 1 and Arcady's soldiers 1 and 2.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long int sh = 0, a, f, p = 1, c = 1000000000, k, b = 97, m, i, s1, s2, s3,
n, q = 0, nl, np, ans = 1000000000, ans1 = -1;
int main() {
cin >> m;
cout << m + m / 2;
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
Alice and Bob don't play games anymore. Now they study properties of all sorts of graphs together. Alice invented the following task: she takes a complete undirected graph with n vertices, chooses some m edges and keeps them. Bob gets the <image> remaining edges.
Alice and Bob are fond of "triangles" in graphs, that is, cycles of length 3. That's why they wonder: what total number of triangles is there in the two graphs formed by Alice and Bob's edges, correspondingly?
Input
The first line contains two space-separated integers n and m (1 ≤ n ≤ 106, 0 ≤ m ≤ 106) — the number of vertices in the initial complete graph and the number of edges in Alice's graph, correspondingly. Then m lines follow: the i-th line contains two space-separated integers ai, bi (1 ≤ ai, bi ≤ n, ai ≠ bi), — the numbers of the two vertices connected by the i-th edge in Alice's graph. It is guaranteed that Alice's graph contains no multiple edges and self-loops. It is guaranteed that the initial complete graph also contains no multiple edges and self-loops.
Consider the graph vertices to be indexed in some way from 1 to n.
Output
Print a single number — the total number of cycles of length 3 in Alice and Bob's graphs together.
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is advised to use the cin, cout streams or the %I64d specifier.
Examples
Input
5 5
1 2
1 3
2 3
2 4
3 4
Output
3
Input
5 3
1 2
2 3
1 3
Output
4
Note
In the first sample Alice has 2 triangles: (1, 2, 3) and (2, 3, 4). Bob's graph has only 1 triangle : (1, 4, 5). That's why the two graphs in total contain 3 triangles.
In the second sample Alice's graph has only one triangle: (1, 2, 3). Bob's graph has three triangles: (1, 4, 5), (2, 4, 5) and (3, 4, 5). In this case the answer to the problem is 4.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007LL;
set<int> adj[1000100];
long long cnt[1000100];
long long intersection(int x, int y) {
long long ret = 0;
set<int>::iterator it;
if (adj[x].size() > adj[y].size()) {
swap(x, y);
}
for (it = adj[x].begin(); it != adj[x].end(); it++) {
if (adj[y].find(*it) != adj[y].end()) {
ret++;
}
}
return ret;
}
int main() {
long long n, m;
scanf("%lld %lld", &n, &m);
long long ans1 = n * (n - 1) * (n - 2) / 6, ans2 = 0;
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d %d", &x, &y);
ans1 -= n - 2 - cnt[x] - cnt[y];
cnt[x]++, cnt[y]++;
}
printf("%lld\n", ans1 + ans2);
return 0;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
Given 2 integers u and v, find the shortest array such that [bitwise-xor](https://en.wikipedia.org/wiki/Bitwise_operation#XOR) of its elements is u, and the sum of its elements is v.
Input
The only line contains 2 integers u and v (0 ≤ u,v ≤ 10^{18}).
Output
If there's no array that satisfies the condition, print "-1". Otherwise:
The first line should contain one integer, n, representing the length of the desired array. The next line should contain n positive integers, the array itself. If there are multiple possible answers, print any.
Examples
Input
2 4
Output
2
3 1
Input
1 3
Output
3
1 1 1
Input
8 5
Output
-1
Input
0 0
Output
0
Note
In the first sample, 3⊕ 1 = 2 and 3 + 1 = 4. There is no valid array of smaller length.
Notice that in the fourth sample the array is empty.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 5;
long long mod = 1e9 + 7;
vector<long long> adj[N];
vector<bool> vis(N);
void dfs(long long x) {
vis[x] = true;
for (long long i = 0; i < adj[x].size(); i++) {
if (!vis[adj[x][i]]) dfs(adj[x][i]);
}
}
long long d, x, y;
void extendedEuclid(long long A, long long B) {
if (B == 0) {
d = A;
x = 1;
y = 0;
} else {
extendedEuclid(B, A % B);
long long temp = x;
x = y;
y = temp - (A / B) * y;
}
}
long long modInverse(long long A, long long M) {
extendedEuclid(A, M);
return (x % M + M) % M;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long a, b;
cin >> a >> b;
if ((abs(a - b)) % 2 == 1 || a > b) {
cout << -1;
return 0;
}
vector<long long> a1(64, 0), b1(64, 0);
for (long long i = 0; i < 64; i++) {
if (a % 2 == 1) a1[i] = 1;
a /= 2;
}
for (long long i = 0; i < 64; i++) {
if (b % 2 == 1) b1[i] = 1;
b /= 2;
}
long long l = 0;
for (long long i = 63; i > 0; i--) {
if (b1[i] % 2 != a1[i]) {
b1[i - 1] += 2;
b1[i]--;
}
}
for (long long i = 0; i < 63; i++) {
if (b1[i] < 0) {
b1[i] += 4;
b1[i + 1] -= 2;
}
}
long long num = 0, c1 = 0, c2 = 0, c3 = 0, k = 1;
for (long long i = 0; i < 64; i++) {
if (b1[i] == 1) {
c1 += k;
} else if (b1[i] == 2) {
c1 += k;
c2 += k;
} else if (b1[i] == 3) {
c1 += k;
c2 += k;
c3 += k;
}
k = k << 1;
num = max(num, b1[i]);
}
cout << num << "\n";
if (c1 > 0) cout << c1 << " ";
if (c2 > 0) cout << c2 << " ";
if (c3 > 0) cout << c3 << " ";
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
The life goes up and down, just like nice sequences. Sequence t1, t2, ..., tn is called nice if the following two conditions are satisfied:
* ti < ti + 1 for each odd i < n;
* ti > ti + 1 for each even i < n.
For example, sequences (2, 8), (1, 5, 1) and (2, 5, 1, 100, 99, 120) are nice, while (1, 1), (1, 2, 3) and (2, 5, 3, 2) are not.
Bear Limak has a sequence of positive integers t1, t2, ..., tn. This sequence is not nice now and Limak wants to fix it by a single swap. He is going to choose two indices i < j and swap elements ti and tj in order to get a nice sequence. Count the number of ways to do so. Two ways are considered different if indices of elements chosen for a swap are different.
Input
The first line of the input contains one integer n (2 ≤ n ≤ 150 000) — the length of the sequence.
The second line contains n integers t1, t2, ..., tn (1 ≤ ti ≤ 150 000) — the initial sequence. It's guaranteed that the given sequence is not nice.
Output
Print the number of ways to swap two elements exactly once in order to get a nice sequence.
Examples
Input
5
2 8 4 7 7
Output
2
Input
4
200 150 100 50
Output
1
Input
10
3 2 1 4 1 4 1 4 1 4
Output
8
Input
9
1 2 3 4 5 6 7 8 9
Output
0
Note
In the first sample, there are two ways to get a nice sequence with one swap:
1. Swap t2 = 8 with t4 = 7.
2. Swap t1 = 2 with t5 = 7.
In the second sample, there is only one way — Limak should swap t1 = 200 with t4 = 50.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int inf = 200000;
vector<int> x, bad, status;
int n;
inline bool is_good(int pos) {
if (pos % 2) return x[pos] < x[pos - 1] and x[pos] < x[pos + 1];
return x[pos] > x[pos - 1] and x[pos] > x[pos + 1];
}
int sum = 0;
inline void update(int pos) {
if (pos <= 0 or pos > n) return;
sum -= status[pos];
status[pos] = is_good(pos);
sum += status[pos];
}
int main() {
cin >> n;
status = vector<int>(n + 5, 0);
x.push_back(inf);
set<pair<int, int> > ans;
for (int i = 0; i < n; i++) {
int tmp;
scanf("%d", &tmp);
x.push_back(tmp);
}
if (n % 2)
x.push_back(inf);
else
x.push_back(0);
int cnt = 0;
for (int i = 1; i <= n; i++) {
if (is_good(i))
sum++, status[i] = 1;
else
bad.push_back(i);
}
cerr << "sum" << '=' << sum << endl;
if (bad.size() > 9) return printf("0\n"), 0;
for (auto i : bad) {
for (int j = 1; j <= n; j++) {
if (i == j) continue;
swap(x[i], x[j]);
update(i);
update(i - 1);
update(i + 1);
update(j);
update(j - 1);
update(j + 1);
if (sum == n) {
ans.insert(make_pair(min(i, j), max(i, j)));
}
swap(x[i], x[j]);
update(i);
update(i - 1);
update(i + 1);
update(j);
update(j - 1);
update(j + 1);
}
}
cout << ans.size() << endl;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
There is a country with n citizens. The i-th of them initially has a_{i} money. The government strictly controls the wealth of its citizens. Whenever a citizen makes a purchase or earns some money, they must send a receipt to the social services mentioning the amount of money they currently have.
Sometimes the government makes payouts to the poor: all citizens who have strictly less money than x are paid accordingly so that after the payout they have exactly x money. In this case the citizens don't send a receipt.
You know the initial wealth of every citizen and the log of all events: receipts and payouts. Restore the amount of money each citizen has after all events.
Input
The first line contains a single integer n (1 ≤ n ≤ 2 ⋅ 10^{5}) — the numer of citizens.
The next line contains n integers a_1, a_2, ..., a_n (0 ≤ a_{i} ≤ 10^{9}) — the initial balances of citizens.
The next line contains a single integer q (1 ≤ q ≤ 2 ⋅ 10^{5}) — the number of events.
Each of the next q lines contains a single event. The events are given in chronological order.
Each event is described as either 1 p x (1 ≤ p ≤ n, 0 ≤ x ≤ 10^{9}), or 2 x (0 ≤ x ≤ 10^{9}). In the first case we have a receipt that the balance of the p-th person becomes equal to x. In the second case we have a payoff with parameter x.
Output
Print n integers — the balances of all citizens after all events.
Examples
Input
4
1 2 3 4
3
2 3
1 2 2
2 1
Output
3 2 3 4
Input
5
3 50 2 1 10
3
1 2 0
2 8
1 3 20
Output
8 8 20 8 10
Note
In the first example the balances change as follows: 1 2 3 4 → 3 3 3 4 → 3 2 3 4 → 3 2 3 4
In the second example the balances change as follows: 3 50 2 1 10 → 3 0 2 1 10 → 8 8 8 8 10 → 8 8 20 8 10
### Response
```cpp
#include <bits/stdc++.h>
namespace kyel {
const int maxn(212345);
int n, q, val[maxn], rank[maxn];
int change[maxn], cr[maxn], end;
int find(int v) {
int left(0), right(end - 1), ret(-1);
while (left <= right) {
int mid(left + right >> 1);
if (cr[mid] > v)
right = mid - 1, ret = mid;
else
left = mid + 1;
}
return ret;
}
void kyel() {
scanf("%d", &n);
for (int i(1); i <= n; ++i) scanf("%d", val + i);
scanf("%d", &q);
for (int i(1); i <= q; ++i) {
int cmd, x, y;
scanf("%d%d", &cmd, &x);
if (cmd == 1) {
scanf("%d", &y);
val[x] = y, rank[x] = i;
} else {
while (end && change[end - 1] <= x) --end;
change[end] = x, cr[end++] = i;
}
}
for (int i(1); i <= n; ++i) {
int pos(find(rank[i]));
if (~pos && change[pos] > val[i]) val[i] = change[pos];
printf("%d", val[i]);
if (i != n) printf(" ");
}
printf("\n");
}
} // namespace kyel
int main() {
kyel::kyel();
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Consider an analog clock whose hour and minute hands are A and B centimeters long, respectively.
An endpoint of the hour hand and an endpoint of the minute hand are fixed at the same point, around which each hand rotates clockwise at constant angular velocity. It takes the hour and minute hands 12 hours and 1 hour to make one full rotation, respectively.
At 0 o'clock, the two hands overlap each other. H hours and M minutes later, what is the distance in centimeters between the unfixed endpoints of the hands?
Constraints
* All values in input are integers.
* 1 \leq A, B \leq 1000
* 0 \leq H \leq 11
* 0 \leq M \leq 59
Input
Input is given from Standard Input in the following format:
A B H M
Output
Print the answer without units. Your output will be accepted when its absolute or relative error from the correct value is at most 10^{-9}.
Examples
Input
3 4 9 0
Output
5.00000000000000000000
Input
3 4 10 40
Output
4.56425719433005567605
### Response
```cpp
#include <bits/stdc++.h>
#include <cmath>
using namespace std;
int main() {
int a, b, h, m;
double ang;
cin >> a >> b >> h >> m;
ang = 2 * M_PI * ((m / 60.0 + h) / 12.0 - m / 60.0);
printf("%.15f\n", sqrt(pow(a, 2) + pow(b, 2) - (2.0 * a * b * cos(ang))));
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
It is a balmy spring afternoon, and Farmer John's n cows are ruminating about link-cut cacti in their stalls. The cows, labeled 1 through n, are arranged so that the i-th cow occupies the i-th stall from the left. However, Elsie, after realizing that she will forever live in the shadows beyond Bessie's limelight, has formed the Mischievous Mess Makers and is plotting to disrupt this beautiful pastoral rhythm. While Farmer John takes his k minute long nap, Elsie and the Mess Makers plan to repeatedly choose two distinct stalls and swap the cows occupying those stalls, making no more than one swap each minute.
Being the meticulous pranksters that they are, the Mischievous Mess Makers would like to know the maximum messiness attainable in the k minutes that they have. We denote as pi the label of the cow in the i-th stall. The messiness of an arrangement of cows is defined as the number of pairs (i, j) such that i < j and pi > pj.
Input
The first line of the input contains two integers n and k (1 ≤ n, k ≤ 100 000) — the number of cows and the length of Farmer John's nap, respectively.
Output
Output a single integer, the maximum messiness that the Mischievous Mess Makers can achieve by performing no more than k swaps.
Examples
Input
5 2
Output
10
Input
1 10
Output
0
Note
In the first sample, the Mischievous Mess Makers can swap the cows in the stalls 1 and 5 during the first minute, then the cows in stalls 2 and 4 during the second minute. This reverses the arrangement of cows, giving us a total messiness of 10.
In the second sample, there is only one cow, so the maximum possible messiness is 0.
### Response
```cpp
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:128777216")
const int null = 0;
using namespace std;
template <class T, class Q>
class hash_map : unordered_map<T, Q> {};
template <class T>
int size(const T &a) {
return int(a.size());
}
template <class T>
T abs(const T &a) {
return (a < 0 ? -a : a);
}
template <class T>
T sqr(const T &a) {
return a * a;
}
long long mod = int(1e9 + 7.1);
template <class T>
inline T msum(T a, T b) {
return (a + b < mod ? a + b : a + b - mod);
}
template <class T>
inline void madd(T &a, T b) {
a = msum(a, b);
}
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
long long n, k;
cin >> n >> k;
k = min(k, n / 2);
cout << k * (n - k) + (n - k - k) * k + k * (k - 1) << endl;
return 0;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
Thought it is already the XXI century, the Mass Media isn't very popular in Walrusland. The cities get news from messengers who can only travel along roads. The network of roads in Walrusland is built so that it is possible to get to any city from any other one in exactly one way, and the roads' lengths are equal.
The North Pole governor decided to carry out an information reform. Several cities were decided to be chosen and made regional centers. Maintaining a region center takes k fishlars (which is a local currency) per year. It is assumed that a regional center always has information on the latest news.
For every city which is not a regional center, it was decided to appoint a regional center which will be responsible for keeping this city informed. In that case the maintenance costs will be equal to dlen fishlars per year, where len is the distance from a city to the corresponding regional center, measured in the number of roads along which one needs to go.
Your task is to minimize the costs to carry out the reform.
Input
The first line contains two given numbers n and k (1 ≤ n ≤ 180, 1 ≤ k ≤ 105).
The second line contains n - 1 integers di, numbered starting with 1 (di ≤ di + 1, 0 ≤ di ≤ 105).
Next n - 1 lines contain the pairs of cities connected by a road.
Output
On the first line print the minimum number of fishlars needed for a year's maintenance. On the second line print n numbers, where the i-th number will represent the number of the regional center, appointed to the i-th city. If the i-th city is a regional center itself, then you should print number i.
If there are several solutions to that problem, print any of them.
Examples
Input
8 10
2 5 9 11 15 19 20
1 4
1 3
1 7
4 6
2 8
2 3
3 5
Output
38
3 3 3 4 3 4 3 3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<long long> e[301];
long long n, k, d[301], f[301][301], dp[301][301], mini[301], wwk[301];
void tr_dp(long long x, long long dd) {
for (long long i = 1; i <= n; i++) dp[x][i] = d[f[x][i]] + k;
for (long long i = 0; i < e[x].size(); i++) {
long long y = e[x][i];
if (dd == y) continue;
tr_dp(y, x);
for (long long j = 1; j <= n; j++)
dp[x][j] += min(dp[y][mini[y]], dp[y][j] - k);
}
mini[x] = 1;
for (long long i = 2; i <= n; i++)
if (dp[x][i] < dp[x][mini[x]]) mini[x] = i;
}
void tr_put(long long x, long long dd, long long ff) {
wwk[x] = ff;
for (long long i = 0; i < e[x].size(); i++) {
long long y = e[x][i];
if (y == dd) continue;
if (dp[y][mini[y]] < dp[y][ff] - k)
tr_put(y, x, mini[y]);
else
tr_put(y, x, ff);
}
}
int main() {
scanf("%lld%lld", &n, &k);
for (long long i = 1; i < n; i++) scanf("%lld", &d[i]);
memset(f, 0x3f3f3f3f, sizeof(f));
for (long long i = 1; i <= n; i++) f[i][i] = 0;
for (long long i = 1; i < n; i++) {
long long a, b;
scanf("%lld%lld", &a, &b);
e[a].push_back(b);
e[b].push_back(a);
f[a][b] = 1;
f[b][a] = 1;
}
for (long long k = 1; k <= n; k++)
for (long long i = 1; i <= n; i++)
for (long long j = 1; j <= n; j++)
f[i][j] = min(f[i][j], f[i][k] + f[k][j]);
tr_dp(1, 0);
printf("%lld\n", dp[1][mini[1]]);
tr_put(1, 0, mini[1]);
for (long long i = 1; i <= n; i++) printf("%lld ", wwk[i]);
}
``` |
### Prompt
Create a solution in cpp for the following problem:
Limak is an old brown bear. He often goes bowling with his friends. Today he feels really good and tries to beat his own record!
For rolling a ball one gets a score — an integer (maybe negative) number of points. Score for i-th roll is multiplied by i and scores are summed up. So, for k rolls with scores s1, s2, ..., sk, total score is <image>. Total score is 0 if there were no rolls.
Limak made n rolls and got score ai for i-th of them. He wants to maximize his total score and he came up with an interesting idea. He will cancel some rolls, saying that something distracted him or there was a strong wind.
Limak is able to cancel any number of rolls, maybe even all or none of them. Total score is calculated as if there were only non-canceled rolls. Look at the sample tests for clarification. What maximum total score can Limak get?
Input
The first line contains single integer n (1 ≤ n ≤ 105).
The second line contains n space-separated integers a1, a2, ..., an (|ai| ≤ 107) - scores for Limak's rolls.
Output
Print the maximum possible total score after choosing rolls to cancel.
Examples
Input
5
-2 -8 0 5 -3
Output
13
Input
6
-10 20 -30 40 -50 60
Output
400
Note
In first sample Limak should cancel rolls with scores - 8 and - 3. Then he is left with three rolls with scores - 2, 0, 5. Total score is 1·( - 2) + 2·0 + 3·5 = 13.
In second sample Limak should cancel roll with score - 50. Total score is 1·( - 10) + 2·20 + 3·( - 30) + 4·40 + 5·60 = 400.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 110000;
long long a[N], t[N], x[N], y[N], s[N];
int id[N], used[N], c[N];
vector<int> V[400];
int main() {
ios::sync_with_stdio(0);
int n;
cin >> n;
long long ans = 0, cur = 0;
for (int i = 0; i < n; i++) cin >> a[i], cur += (i + 1) * a[i];
ans = cur;
for (int i = 0; i < n; i++) s[i + 1] = s[i] + a[i];
auto cross = [&](int u, int v, int w) {
return (x[v] - x[u]) * (y[w] - y[u]) - (x[w] - x[u]) * (y[v] - y[u]);
};
auto convex_hull = [&](vector<int> &a) {
vector<int> b;
for (int i : a) {
while (b.size() > 1 && cross(b[b.size() - 2], b.back(), i) <= 0)
b.pop_back();
b.push_back(i);
}
a = b;
};
int m = 500;
auto build = [&](int from, int to, int flag = 1) {
int j = from / m;
V[j].clear();
int cnt = 0;
long long tot = 0;
for (int i = from; i < to; i++)
if (!used[i]) tot += a[i];
long long sum = 0;
if (!flag) {
for (int i = from; i < to; i++) id[i] = i;
sort(id + from, id + to, [](int i, int j) { return a[i] > a[j]; });
}
for (int i = from; i < to; i++) {
if (used[i])
cnt++;
else {
sum += a[i];
y[i] = (i + 1 - cnt) * 1LL * a[i] + tot - sum;
x[i] = -a[i];
}
}
vector<int> v;
for (int i = from; i < to; i++) {
int k = id[i];
if (used[k]) continue;
v.push_back(k);
}
for (int i = 0, k; i < v.size(); i = k) {
auto cur = make_pair(y[v[i]], v[i]);
for (k = i; k < v.size() && x[v[i]] == x[v[k]]; k++) {
if (y[v[k]] < cur.first) {
cur.first = y[v[k]];
cur.second = v[k];
}
}
V[j].push_back(cur.second);
}
convex_hull(V[j]);
c[j] = cnt, t[j] = tot;
};
auto calc = [&](int u, long long p) {
assert(abs(y[u]) <= 1.5e12);
assert(abs(x[u]) <= 1.5e7);
return p * x[u] + y[u];
};
for (int i = 0; i < n; i += m) build(i, min(n, i + m), 0);
auto get = [&](int id, long long x) {
auto ret = make_pair(LONG_LONG_MAX, -1);
if (V[id].empty()) return ret;
int st = 0, en = V[id].size() - 1;
while (en - st > 2) {
int mid1 = (st * 2 + en) / 3;
int mid2 = (st + en * 2) / 3;
long long ret1 = calc(V[id][mid1], x);
long long ret2 = calc(V[id][mid2], x);
if (ret1 < ret2) {
en = mid2;
} else {
st = mid1;
}
}
assert(st <= en);
for (int i = st; i <= en; i++) {
int u = V[id][i];
long long cur = calc(u, x);
if (cur < ret.first) {
ret.first = cur;
ret.second = u;
}
}
return ret;
};
cur = s[n];
long long cost = ans;
for (int i = n - 1; i > 0; i--) {
long long tsum = 0, csum = 0;
long long dmin = LONG_LONG_MAX;
int u = -1;
int flag = 0;
for (int j = 0; j < (n - 1) / m + 1; j++) {
tsum += t[j];
if (V[j].empty()) {
csum += c[j];
continue;
}
flag = 1;
auto sol = get(j, csum);
if (dmin > cur - tsum + sol.first) {
dmin = cur - tsum + sol.first;
u = sol.second;
}
csum += c[j];
}
assert(flag);
cur -= a[u];
cost -= dmin;
used[u] = 1;
build(u / m * m, min((u / m + 1) * m, n));
ans = max(ans, cost);
}
ans = max(ans, 0LL);
cout << ans << endl;
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
The stardate is 1983, and Princess Heidi is getting better at detecting the Death Stars. This time, two Rebel spies have yet again given Heidi two maps with the possible locations of the Death Star. Since she got rid of all double agents last time, she knows that both maps are correct, and indeed show the map of the solar system that contains the Death Star. However, this time the Empire has hidden the Death Star very well, and Heidi needs to find a place that appears on both maps in order to detect the Death Star.
The first map is an N × M grid, each cell of which shows some type of cosmic object that is present in the corresponding quadrant of space. The second map is an M × N grid. Heidi needs to align those two maps in such a way that they overlap over some M × M section in which all cosmic objects are identical. Help Heidi by identifying where such an M × M section lies within both maps.
Input
The first line of the input contains two space-separated integers N and M (1 ≤ N ≤ 2000, 1 ≤ M ≤ 200, M ≤ N). The next N lines each contain M lower-case Latin characters (a-z), denoting the first map. Different characters correspond to different cosmic object types. The next M lines each contain N characters, describing the second map in the same format.
Output
The only line of the output should contain two space-separated integers i and j, denoting that the section of size M × M in the first map that starts at the i-th row is equal to the section of the second map that starts at the j-th column. Rows and columns are numbered starting from 1.
If there are several possible ways to align the maps, Heidi will be satisfied with any of those. It is guaranteed that a solution exists.
Example
Input
10 5
somer
andom
noise
mayth
eforc
ebewi
thyou
hctwo
again
noise
somermayth
andomeforc
noiseebewi
againthyou
noisehctwo
Output
4 6
Note
The 5-by-5 grid for the first test case looks like this:
mayth
eforc
ebewi
thyou
hctwo
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int p = 131;
int n, m;
char a[2005][205], b[205][2005];
unsigned int ha[2005];
unsigned int s1[2005], s2[2005];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) {
scanf("%s", a[i]);
ha[i] = hash<string>()(string(a[i], a[i] + m));
}
for (int i = 0; i <= (n - m); ++i)
for (int j = 0; j < m; ++j) s1[i] = s1[i] * p + ha[i + j];
for (int i = 0; i < m; ++i) {
scanf("%s", b[i]);
for (int j = 0; j <= (n - m); ++j)
s2[j] = s2[j] * p + hash<string>()(string(b[i] + j, b[i] + j + m));
}
for (int i = 0; i <= (n - m); ++i)
for (int j = 0; j <= (n - m); ++j)
if (s1[i] == s2[j]) {
printf("%d %d\n", i + 1, j + 1);
return 0;
}
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
You are a paparazzi working in Manhattan.
Manhattan has r south-to-north streets, denoted by numbers 1, 2,…, r in order from west to east, and r west-to-east streets, denoted by numbers 1,2,…,r in order from south to north. Each of the r south-to-north streets intersects each of the r west-to-east streets; the intersection between the x-th south-to-north street and the y-th west-to-east street is denoted by (x, y). In order to move from the intersection (x,y) to the intersection (x', y') you need |x-x'|+|y-y'| minutes.
You know about the presence of n celebrities in the city and you want to take photos of as many of them as possible. More precisely, for each i=1,..., n, you know that the i-th celebrity will be at the intersection (x_i, y_i) in exactly t_i minutes from now (and he will stay there for a very short time, so you may take a photo of him only if at the t_i-th minute from now you are at the intersection (x_i, y_i)). You are very good at your job, so you are able to take photos instantaneously. You know that t_i < t_{i+1} for any i=1,2,…, n-1.
Currently you are at your office, which is located at the intersection (1, 1). If you plan your working day optimally, what is the maximum number of celebrities you can take a photo of?
Input
The first line of the input contains two positive integers r, n (1≤ r≤ 500, 1≤ n≤ 100,000) – the number of south-to-north/west-to-east streets and the number of celebrities.
Then n lines follow, each describing the appearance of a celebrity. The i-th of these lines contains 3 positive integers t_i, x_i, y_i (1≤ t_i≤ 1,000,000, 1≤ x_i, y_i≤ r) — denoting that the i-th celebrity will appear at the intersection (x_i, y_i) in t_i minutes from now.
It is guaranteed that t_i<t_{i+1} for any i=1,2,…, n-1.
Output
Print a single integer, the maximum number of celebrities you can take a photo of.
Examples
Input
10 1
11 6 8
Output
0
Input
6 9
1 2 6
7 5 1
8 5 5
10 3 1
12 4 4
13 6 2
17 6 6
20 1 4
21 5 4
Output
4
Input
10 4
1 2 1
5 10 9
13 8 8
15 9 9
Output
1
Input
500 10
69 477 122
73 186 235
341 101 145
372 77 497
390 117 440
494 471 37
522 300 498
682 149 379
821 486 359
855 157 386
Output
3
Note
Explanation of the first testcase: There is only one celebrity in the city, and he will be at intersection (6,8) exactly 11 minutes after the beginning of the working day. Since you are initially at (1,1) and you need |1-6|+|1-8|=5+7=12 minutes to reach (6,8) you cannot take a photo of the celebrity. Thus you cannot get any photo and the answer is 0.
Explanation of the second testcase: One way to take 4 photos (which is the maximum possible) is to take photos of celebrities with indexes 3, 5, 7, 9 (see the image for a visualization of the strategy):
* To move from the office at (1,1) to the intersection (5,5) you need |1-5|+|1-5|=4+4=8 minutes, so you arrive at minute 8 and you are just in time to take a photo of celebrity 3.
* Then, just after you have taken a photo of celebrity 3, you move toward the intersection (4,4). You need |5-4|+|5-4|=1+1=2 minutes to go there, so you arrive at minute 8+2=10 and you wait until minute 12, when celebrity 5 appears.
* Then, just after you have taken a photo of celebrity 5, you go to the intersection (6,6). You need |4-6|+|4-6|=2+2=4 minutes to go there, so you arrive at minute 12+4=16 and you wait until minute 17, when celebrity 7 appears.
* Then, just after you have taken a photo of celebrity 7, you go to the intersection (5,4). You need |6-5|+|6-4|=1+2=3 minutes to go there, so you arrive at minute 17+3=20 and you wait until minute 21 to take a photo of celebrity 9.
<image>
Explanation of the third testcase: The only way to take 1 photo (which is the maximum possible) is to take a photo of the celebrity with index 1 (since |2-1|+|1-1|=1, you can be at intersection (2,1) after exactly one minute, hence you are just in time to take a photo of celebrity 1).
Explanation of the fourth testcase: One way to take 3 photos (which is the maximum possible) is to take photos of celebrities with indexes 3, 8, 10:
* To move from the office at (1,1) to the intersection (101,145) you need |1-101|+|1-145|=100+144=244 minutes, so you can manage to be there when the celebrity 3 appears (at minute 341).
* Then, just after you have taken a photo of celebrity 3, you move toward the intersection (149,379). You need |101-149|+|145-379|=282 minutes to go there, so you arrive at minute 341+282=623 and you wait until minute 682, when celebrity 8 appears.
* Then, just after you have taken a photo of celebrity 8, you go to the intersection (157,386). You need |149-157|+|379-386|=8+7=15 minutes to go there, so you arrive at minute 682+15=697 and you wait until minute 855 to take a photo of celebrity 10.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAX_D = 1e3 + 100;
const int MAX_N = 1e5 + 5;
const int INF = 1e9 + 5;
int dp[MAX_N];
int cdp[MAX_N];
int x[MAX_N], y[MAX_N], t[MAX_N];
bool can(int i, int j) {
return abs(x[i] - x[j]) + abs(y[i] - y[j]) <= abs(t[i] - t[j]);
}
int main() {
int R, n;
cin >> R >> n;
x[0] = 1;
y[0] = 1;
for (int i = 1; i <= n; i++) {
cin >> t[i] >> x[i] >> y[i];
}
cdp[0] = -INF;
for (int i = 1; i <= n; i++) {
dp[i] = -INF;
if (can(0, i)) {
dp[i] = 1;
}
for (int j = 1; j < MAX_D && 0 < i - j; j++) {
if (can(i - j, i)) {
dp[i] = max(dp[i], 1 + dp[i - j]);
}
}
if (i - MAX_D > 0) {
dp[i] = max(dp[i], 1 + cdp[i - MAX_D]);
}
cdp[i] = max(cdp[i - 1], dp[i]);
}
cout << max(0, cdp[n]) << '\n';
}
``` |
### Prompt
Generate a CPP solution to the following problem:
Boy Dima gave Julian a birthday present — set B consisting of positive integers. However, he didn't know, that Julian hates sets, but enjoys bipartite graphs more than anything else!
Julian was almost upset, but her friend Alex said, that he can build an undirected graph using this set in such a way: let all integer numbers be vertices, then connect any two i and j with an edge if |i - j| belongs to B.
Unfortunately, Julian doesn't like the graph, that was built using B. Alex decided to rectify the situation, so he wants to erase some numbers from B, so that graph built using the new set is bipartite. The difficulty of this task is that the graph, Alex has to work with, has an infinite number of vertices and edges! It is impossible to solve this task alone, so Alex asks you for help. Write a program that erases a subset of minimum size from B so that graph constructed on the new set is bipartite.
Recall, that graph is bipartite if all its vertices can be divided into two disjoint sets such that every edge connects a vertex from different sets.
Input
First line contains an integer n ~ (1 ⩽ n ⩽ 200 000) — size of B
Second line contains n integers b_1, b_2, …, b_n ~ (1 ⩽ b_i ⩽ 10^{18}) — numbers of B, all b_i are unique
Output
In the first line print single integer k – the number of erased elements. In the second line print k integers — values of erased elements.
If there are multiple answers, print any of them.
Examples
Input
3
1 2 3
Output
1
2
Input
2
2 6
Output
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200020;
int n, idx, cnt;
long long b[maxn];
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> b[i];
for (int i = 0; i < 60; i++) {
long long c = 1LL << i;
long long cc = c << 1;
int tmp = 0;
for (int j = 0; j < n; j++) {
if (b[j] % c == 0 && b[j] % cc) tmp++;
}
if (tmp > cnt) {
idx = i;
cnt = tmp;
}
}
cout << n - cnt << endl;
for (int i = 0; i < n; i++) {
long long c = 1LL << idx;
long long cc = c << 1;
if (!(b[i] % c == 0 && b[i] % cc)) {
cout << b[i] << " ";
}
}
return 0;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
You are given a string S of length N consisting of `A`, `B` and `C`, and an integer K which is between 1 and N (inclusive). Print the string S after lowercasing the K-th character in it.
Constraints
* 1 ≤ N ≤ 50
* 1 ≤ K ≤ N
* S is a string of length N consisting of `A`, `B` and `C`.
Input
Input is given from Standard Input in the following format:
N K
S
Output
Print the string S after lowercasing the K-th character in it.
Examples
Input
3 1
ABC
Output
aBC
Input
4 3
CABA
Output
CAbA
### Response
```cpp
#include<iostream>
using namespace std;
int main(){
int N,K;
string S,A;
cin >> N >> K >> S;
S[K-1] = tolower(S[K-1]);
cout << S;
return 0;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
You are given an undirected tree consisting of n vertices. An undirected tree is a connected undirected graph with n - 1 edges.
Your task is to add the minimum number of edges in such a way that the length of the shortest path from the vertex 1 to any other vertex is at most 2. Note that you are not allowed to add loops and multiple edges.
Input
The first line contains one integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of vertices in the tree.
The following n - 1 lines contain edges: edge i is given as a pair of vertices u_i, v_i (1 ≤ u_i, v_i ≤ n). It is guaranteed that the given edges form a tree. It is guaranteed that there are no loops and multiple edges in the given edges.
Output
Print a single integer — the minimum number of edges you have to add in order to make the shortest distance from the vertex 1 to any other vertex at most 2. Note that you are not allowed to add loops and multiple edges.
Examples
Input
7
1 2
2 3
2 4
4 5
4 6
5 7
Output
2
Input
7
1 2
1 3
2 4
2 5
3 6
1 7
Output
0
Input
7
1 2
2 3
3 4
3 5
3 6
3 7
Output
1
Note
The tree corresponding to the first example: <image> The answer is 2, some of the possible answers are the following: [(1, 5), (1, 6)], [(1, 4), (1, 7)], [(1, 6), (1, 7)].
The tree corresponding to the second example: <image> The answer is 0.
The tree corresponding to the third example: <image> The answer is 1, only one possible way to reach it is to add the edge (1, 3).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
vector<int> v[N];
int n;
int p[N];
int de[N];
void dfs(int now, int pre, int d = 0) {
p[now] = pre;
de[now] = d;
for (auto k : v[now]) {
if (k == pre) continue;
dfs(k, now, d + 1);
}
}
set<pair<int, int> > s;
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i < n; i++) {
int s, t;
cin >> s >> t;
v[s].push_back(t);
v[t].push_back(s);
}
dfs(1, 0);
for (int i = 1; i <= n; i++) {
if (de[i] > 2) s.insert({-de[i], i});
}
int ans = 0;
while (!s.empty()) {
ans++;
auto t = *s.begin();
int vv = p[t.second];
pair<int, int> x = {-de[vv], vv};
auto G = s.find(x);
if (G != s.end()) s.erase(G);
for (auto k : v[vv]) {
pair<int, int> x = {-de[k], k};
auto G = s.find(x);
if (G != s.end()) s.erase(G);
}
}
cout << ans << '\n';
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
Alexey recently held a programming contest for students from Berland. n students participated in a contest, i-th of them solved ai problems. Now he wants to award some contestants. Alexey can award the students with diplomas of three different degrees. Each student either will receive one diploma of some degree, or won't receive any diplomas at all. Let cntx be the number of students that are awarded with diplomas of degree x (1 ≤ x ≤ 3). The following conditions must hold:
* For each x (1 ≤ x ≤ 3) cntx > 0;
* For any two degrees x and y cntx ≤ 2·cnty.
Of course, there are a lot of ways to distribute the diplomas. Let bi be the degree of diploma i-th student will receive (or - 1 if i-th student won't receive any diplomas). Also for any x such that 1 ≤ x ≤ 3 let cx be the maximum number of problems solved by a student that receives a diploma of degree x, and dx be the minimum number of problems solved by a student that receives a diploma of degree x. Alexey wants to distribute the diplomas in such a way that:
1. If student i solved more problems than student j, then he has to be awarded not worse than student j (it's impossible that student j receives a diploma and i doesn't receive any, and also it's impossible that both of them receive a diploma, but bj < bi);
2. d1 - c2 is maximum possible;
3. Among all ways that maximize the previous expression, d2 - c3 is maximum possible;
4. Among all ways that correspond to the two previous conditions, d3 - c - 1 is maximum possible, where c - 1 is the maximum number of problems solved by a student that doesn't receive any diploma (or 0 if each student is awarded with some diploma).
Help Alexey to find a way to award the contestants!
Input
The first line contains one integer number n (3 ≤ n ≤ 3000).
The second line contains n integer numbers a1, a2, ..., an (1 ≤ ai ≤ 5000).
Output
Output n numbers. i-th number must be equal to the degree of diploma i-th contestant will receive (or - 1 if he doesn't receive any diploma).
If there are multiple optimal solutions, print any of them. It is guaranteed that the answer always exists.
Examples
Input
4
1 2 3 4
Output
3 3 2 1
Input
6
1 4 3 1 1 2
Output
-1 1 2 -1 -1 3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 3005;
vector<pair<int, int>> ds;
struct max_deque {
int le, ri;
int st[N];
void reset() {
le = 0;
ri = -1;
}
max_deque() { reset(); }
bool update(int l, int r) {
if (l > r || l >= ds.size() || r < 0) return false;
if (le > ri || st[ri] < l || st[le] > r)
reset();
else {
while (le <= ri && st[le] < l) ++le;
}
if (le <= ri) l = max(l, st[ri] + 1);
while (l <= r) {
while (le <= ri && ds[st[ri]].first - ds[st[ri] + 1].first <
ds[l].first - ds[l + 1].first)
--ri;
st[++ri] = l;
++l;
}
return true;
}
int get() { return st[le]; }
};
max_deque dq;
pair<int, pair<int, int>> ans = {0, {0, 0}};
pair<int, pair<int, int>> kq;
int deg[N];
void answer(int cnt1, int cnt2, int cnt3) {
int v1 = -ds[cnt1].first + ds[cnt1 - 1].first;
int v2 = -ds[cnt1 + cnt2].first + ds[cnt1 + cnt2 - 1].first;
int v3 = -ds[cnt1 + cnt2 + cnt3].first + ds[cnt1 + cnt2 + cnt3 - 1].first;
pair<int, pair<int, int>> res = {v1, {v2, v3}};
if (res > ans) {
ans = res;
kq = {cnt1, {cnt2, cnt3}};
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int a;
scanf("%d", &a);
ds.emplace_back(a, i);
}
sort(ds.begin(), ds.end(), greater<pair<int, int>>());
ds.emplace_back(0, n + 1);
for (int i = 0; i < n; i++) {
int cnt1 = i + 1;
dq.reset();
for (int j = i + 1; j < n; j++) {
int cnt2 = j - i;
if (cnt2 <= cnt1 * 2 && cnt1 <= cnt2 * 2) {
if (dq.update(j + (max(cnt1, cnt2) + 1) / 2,
min(j + 2 * min(cnt1, cnt2), n - 1)))
answer(cnt1, cnt2, dq.get() - j);
}
}
}
int cnt1 = kq.first - 1;
int cnt2 = cnt1 + kq.second.first;
int cnt3 = cnt2 + kq.second.second;
for (int i = 0; i < n; i++) {
int t = -1;
if (i <= cnt1)
t = 1;
else if (i <= cnt2)
t = 2;
else if (i <= cnt3)
t = 3;
deg[ds[i].second] = t;
}
for (int i = 1; i <= n; i++) printf("%d ", deg[i]);
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
A string S of an odd length is said to be a strong palindrome if and only if all of the following conditions are satisfied:
* S is a palindrome.
* Let N be the length of S. The string formed by the 1-st through ((N-1)/2)-th characters of S is a palindrome.
* The string consisting of the (N+3)/2-st through N-th characters of S is a palindrome.
Determine whether S is a strong palindrome.
Constraints
* S consists of lowercase English letters.
* The length of S is an odd number between 3 and 99 (inclusive).
Input
Input is given from Standard Input in the following format:
S
Output
If S is a strong palindrome, print `Yes`; otherwise, print `No`.
Examples
Input
akasaka
Output
Yes
Input
level
Output
No
Input
atcoder
Output
No
### Response
```cpp
#include<iostream>
#include<string>
using namespace std;
int main(){
string s;
cin>>s;
size_t n=s.length();
for(int i=0;i<(n-1)/2;i++){
if(s[i]!=s[(n+1)/2+i]){
cout<<"No"<<endl;
return 0;
}
}
cout<<"Yes"<<endl;
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
You are given a text consisting of n space-separated words. There is exactly one space character between any pair of adjacent words. There are no spaces before the first word and no spaces after the last word. The length of text is the number of letters and spaces in it. w_i is the i-th word of text. All words consist only of lowercase Latin letters.
Let's denote a segment of words w[i..j] as a sequence of words w_i, w_{i + 1}, ..., w_j. Two segments of words w[i_1 .. j_1] and w[i_2 .. j_2] are considered equal if j_1 - i_1 = j_2 - i_2, j_1 ≥ i_1, j_2 ≥ i_2, and for every t ∈ [0, j_1 - i_1] w_{i_1 + t} = w_{i_2 + t}. For example, for the text "to be or not to be" the segments w[1..2] and w[5..6] are equal, they correspond to the words "to be".
An abbreviation is a replacement of some segments of words with their first uppercase letters. In order to perform an abbreviation, you have to choose at least two non-intersecting equal segments of words, and replace each chosen segment with the string consisting of first letters of the words in the segment (written in uppercase). For example, for the text "a ab a a b ab a a b c" you can replace segments of words w[2..4] and w[6..8] with an abbreviation "AAA" and obtain the text "a AAA b AAA b c", or you can replace segments of words w[2..5] and w[6..9] with an abbreviation "AAAB" and obtain the text "a AAAB AAAB c".
What is the minimum length of the text after at most one abbreviation?
Input
The first line of the input contains one integer n (1 ≤ n ≤ 300) — the number of words in the text.
The next line contains n space-separated words of the text w_1, w_2, ..., w_n. Each word consists only of lowercase Latin letters.
It is guaranteed that the length of text does not exceed 10^5.
Output
Print one integer — the minimum length of the text after at most one abbreviation.
Examples
Input
6
to be or not to be
Output
12
Input
10
a ab a a b ab a a b c
Output
13
Input
6
aa bb aa aa bb bb
Output
11
Note
In the first example you can obtain the text "TB or not TB".
In the second example you can obtain the text "a AAAB AAAB c".
In the third example you can obtain the text "AB aa AB bb".
### Response
```cpp
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:167772160000")
template <typename T>
using min_heap = std::priority_queue<T, std::vector<T>, std::greater<T>>;
template <typename T>
using max_heap = std::priority_queue<T, std::vector<T>, std::less<T>>;
using namespace std;
const long long A1 = 999999929;
const long long B1 = 999999937;
const long long A2 = 1000000007;
const long long B2 = 1000000009;
struct Hash {
long long a, b;
string orig;
Hash(const string& s) {
a = 0;
b = 0;
orig = s;
long long A = 1;
long long B = 1;
for (int i = (s.length() - 1); i >= (0); i--) {
int c = s[i];
a = (a + A * c) % B1;
b = (b + B * c) % B2;
A *= A1;
B *= A2;
}
}
bool eq(Hash other) { return a == other.a && b == other.b; }
};
struct Data {
Hash h = Hash("");
int len;
Data(const string& s) {
h = Hash(s);
len = s.length();
}
};
vector<Data> words;
long long prefSum[100000];
int n;
int totalLength = 0, spaceLength;
vector<Data> make(int start, int len) {
vector<Data> v;
int i = start;
while (v.size() < len && i < n) {
v.push_back(words[i]);
i++;
}
return v;
}
bool eq(std::pair<int, int> a, std::pair<int, int> b) {
if (a.second - a.first != b.second - b.first) return false;
for (int i = (a.first); i < (a.second); i++) {
if (!words[i].h.eq(words[i - a.first + b.first].h)) return false;
}
return true;
}
long long getSum(int from, int to) {
long long ans = prefSum[to];
if (from > 0) ans -= prefSum[from - 1];
return ans;
}
bool isPossible(int len) {
for (int s1 = (0); s1 < (n - len + 1); s1++) {
for (int s2 = (s1 + len); s2 < (n - len + 1); s2++) {
std::pair<int, int> a = {s1, s1 + len};
std::pair<int, int> b = {s2, s2 + len};
if (eq(a, b)) {
return true;
}
}
}
return false;
}
int solve(int len) {
int best = ((1LL << 31) - 1);
for (int s1 = (0); s1 < (n - len + 1); s1++) {
vector<int> starts;
for (int s2 = (s1 + len); s2 < (n - len + 1); s2++) {
std::pair<int, int> a = {s1, s1 + len};
std::pair<int, int> b = {s2, s2 + len};
if (eq(a, b)) {
starts.push_back(s2);
s2 = s2 + len - 1;
}
}
if (starts.size() > 0) {
std::pair<int, int> a = {s1, s1 + len};
int delta = getSum(a.first, a.second - 1);
delta += a.second - a.first;
delta -= a.second - a.first + 1;
for (auto e : starts) {
std::pair<int, int> b = {e, e + len};
delta += getSum(b.first, b.second - 1);
delta += b.second - b.first;
delta -= b.second - b.first + 1;
}
best = min(best, totalLength - delta);
}
}
return best;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
spaceLength = n - 1;
for (int i = (0); i < (n); i++) {
string s;
cin >> s;
totalLength += s.length();
words.push_back(Data(s));
}
prefSum[0] = words[0].len;
for (int i = (1); i < (n); i++) {
prefSum[i] = prefSum[i - 1] + words[i].len;
}
totalLength += spaceLength;
int best = totalLength;
for (int len = (1); len < (n); len++) {
best = min(best, solve(len));
}
cout << best << endl;
return 0;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
Description
KULASIS is the name of a system developed and operated by the Higher Education Research and Development Promotion Organization for the purpose of providing information on common subjects throughout the university on the Web, supporting students and faculty members, and improving services. KULASIS started with the development of the online syllabus in 2003, and has gradually expanded the system to include Web bulletin boards, course registration, grades (scoring registration, scoring confirmation from students).
Students can use functions such as confirmation of academic affairs information (class cancellations, class changes, reports), course registration, and scoring confirmation from both inside and outside the university from a personal computer or mobile phone. The number of logins exceeds 10,000 on many days, and it has become widespread as an academic affairs information system at Kyoto University, and is indispensable for taking common courses throughout the university. We are developing this KULASIS so that it can be applied not only to common subjects throughout the university, but also to undergraduate specialized courses and graduate schools.
http://www.z.k.kyoto-u.ac.jp/introduction_kulasis.html
Q, a student at Kyoto University, was logged in to KULASIS to form a late syllabus. When I was wondering which subject I was going to enter, KULASIS suddenly gave off a dazzling light and moved to another page.
The page to which the transition was made was as shown in the figure below. The subject name and evaluation (impossible, acceptable, good, excellent) are written in the 5x5 square, and 16 ● buttons are arranged on the grid.
It was Q that I did not know what happened, but apparently when I press the ● button on the grid, the evaluation of the subjects in the upper right, lower right, upper left, and lower left is not possible → Yes, Yes → Good, Good → Excellent, Excellent → Impossible.
<image>
You can press the ● button as many times as you like.
I'm not sure if KULASIS has been rewritten by someone or if I'm dreaming, but if I can confirm my grades with this, Q wanted to get as good a grade as possible.
Confident that he was collecting a lot of credits, Q decided to maximize his fighting power in preparation for his assignment to the laboratory six months later than the number of credits itself.
Combat power is the total value of the evaluation of each subject converted into impossible → 0 points, acceptable → 60 points, good → 70 points, excellent → 80 points. It is thought (in the Q department) to show how superior it is.
Now that the subjects displayed on the KULASIS screen and their evaluations are given, please describe the program that outputs the maximum value of the combat power that can be obtained.
Input
The number of test cases is given on the first line of input. The number of test cases is guaranteed to be 100 or less.
From the second line onward, 5x5 numbers are lined up, and the evaluation of the subject displayed on the KULASIS screen is given, and 1,2,3,4 correspond to impossible, acceptable, good, and excellent, respectively.
If it is 0, no subject is registered in that frame.
The test cases are separated by a blank line.
Output
Output the maximum value of combat power that can be obtained for each test case.
Example
Input
5
1 1 0 3 3
1 1 0 3 3
0 0 0 0 0
2 2 0 4 4
2 2 0 4 4
1 1 1 0 0
1 1 1 1 0
1 0 1 1 0
0 0 1 1 1
1 1 1 1 1
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
4 3 4 3 4
3 4 3 4 3
4 3 4 3 4
3 4 3 4 3
4 3 4 3 4
2 2 2 2 2
0 0 0 2 0
2 2 0 2 0
2 2 0 2 0
0 0 0 2 0
Output
1280
1420
0
1920
1020
### Response
```cpp
// template {{{
#include <bits/stdc++.h>
using namespace std;
#define loop(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define rep(i, n) loop(i, 0, n)
#define rloop(i, a, b) for (int i = (int)(b) - 1; i >= (int)(a); i--)
#define rrep(i, n) rloop(i, 0, n)
#define eb emplace_back
#define ef emplace_front
#define pb pop_back
#define pf pop_front
#define all(c) std::begin(c), std::end(c)
#define mp std::make_pair
#define mt std::make_tuple
#define fi first
#define se second
#define popcnt __builtin_popcountll
using uint = unsigned;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<ll>;
using vvl = vector<vl>;
using vd = vector<double>;
using vvd = vector<vd>;
using pi = pair<int, int>;
using pl = pair<ll, ll>;
using pd = pair<double, double>;
using tp = tuple<int, int, int>;
using tp4 = tuple<int, int, int, int>;
using tp5 = tuple<int, int, int, int, int>;
template<typename T>
using max_pq = priority_queue<T, vector<T>, less<T>>;
template<typename T>
using min_pq = priority_queue<T, vector<T>, greater<T>>;
const int MOD = 1e9 + 7;
const int INF = 1e9 + 10;
const ll LLINF = 1e18 + 10;
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, -1, 0, 1};
const int dx8[] = {-1, -1, 0, 1, 1, 1, 0, -1};
const int dy8[] = {0, -1, -1, -1, 0, 1, 1, 1};
template<typename T>
inline T sq(T x){ return x * x; }
template<typename T, typename U>
inline bool chmax(T &x, U y){ if (x >= y) return false; x = y; return true; }
template<typename T, typename U>
inline bool chmin(T &x, U y){ if (x <= y) return false; x = y; return true; }
template<typename T>
inline void sort(T &c){ std::sort(std::begin(c), std::end(c)); }
template<typename T>
inline void reverse(T &c){ std::reverse(std::begin(c), std::end(c)); }
template<typename T>
inline void unique(T &c){ std::sort(std::begin(c), std::end(c)); c.erase(std::unique(all(c)), std::end(c)); }
// }}}
const int t[] = {0, 60, 70, 80};
bool f[5][5];
int a[5][5];
int dp[17][65536];
int calc(int p, int st)
{
if (~dp[p][st]) return dp[p][st];
if (p == 16) return 0;
int res = 0;
int ds = 0;
int x = p / 4, y = p % 4;
rep(i, 4){
chmax(res, ds + calc(p + 1, (st * 4 + i) % 65536));
rep(dx, 2) rep(dy, 2){
if (f[x + dx][y + dy]){
ds -= t[a[x + dx][y + dy]];
++a[x + dx][y + dy] %= 4;
ds += t[a[x + dx][y + dy]];
}
}
}
return dp[p][st] = res;
}
int main()
{
int n;
scanf("%d", &n);
while (n--){
rep(i, 5) rep(j, 5) scanf("%d", &a[i][j]), a[i][j]--;
rep(i, 5) rep(j, 5) f[i][j] = a[i][j] >= 0;
int sum = 0;
rep(i, 5) rep(j, 5){
if (f[i][j]) sum += t[a[i][j]];
}
memset(dp, -1, sizeof(dp));
printf("%d\n", sum + calc(0, 0));
}
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
When Mr. Kay was browsing a certain SNS as usual, the problem that "there are people who can solve IQ150 or more" came to the timeline. Mr. Kay has an IQ of over 150, so he solved the problem in an instant without even looking at it. For him, he doesn't have to work on such a mystery. It is enough to leave it to the computer.
problem
The following mysterious mathematical formula was written in the problem.
* \\ (5 + 3 = 28 \\)
* \\ (9 + 1 = 810 \\)
* \\ (8 + 6 = 214 \\)
* \\ (5 + 4 = 19 \\)
* \\ (2 + 2 = 4 \\)
* \\ (15 + 8 = 723 \\)
* \\ (7 + 9 = -216 \\)
* \\ (3 + 0 = 33 \\)
When thinking about the above operator \\ (+ \\), for a positive integer \\ (a \\) \\ (x \ geq 0, y \ geq 0 \\) and \\ (x + y =) Find the number of integer pairs \\ (x, y \\) such that a \\).
input
A positive integer \\ (a \\) is given on one line.
output
Output the number of pairs \\ ((x, y) \\) that satisfy \\ (a = x + y, x \ geq 0, y \ geq 0 \\) on one line.
Constraint
* \\ (1 \ leq a \ leq 10 ^ 9 (= 1000000000) \\)
Input / output example
Input 1
19
Output 1
1
There is one way of \\ (5 + 4 \\).
Input 2
twenty two
Output 2
2
There are two types: \\ (11 + 11 \\) and \\ (2 + 0 \\).
Input 3
1
Output 3
0
\\ (1 + 0 = 11, 0 + 1 = -11 \\). \\ (1 \\) cannot be generated.
Input 4
101
Output 4
0
Note that \\ (1 --0 \\) is not \\ (101 \\).
Input 5
660233276
Output 5
Four
Example
Input
19
Output
1
### Response
```cpp
#include<iostream>
#include<sstream>
#include<string>
using namespace std;
int string_to_int(const string& str){
int n;
istringstream iss(str);
iss >> n;
return n;
}
bool solve(const string& s, const string& t){
if(t[0] == '0') return false;
int x = s.empty() ? 0 : string_to_int(s);
int y = string_to_int(t);
if(x > y) return false;
return (y-x)%2 == 0;
}
int main(){
int ans=0;
string str, s, t;
cin >> str;
for(int i=0; i<str.size(); ++i){
s = str.substr(0, i);
t = str.substr(i);
if(s.size() > t.size()) break;
if(solve(s, t)) ++ans;
}
cout << ans << endl;
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Snuke has a string x of length N. Initially, every character in x is `0`.
Snuke can do the following two operations any number of times in any order:
* Choose A consecutive characters in x and replace each of them with `0`.
* Choose B consecutive characters in x and replace each of them with `1`.
Find the number of different strings that x can be after Snuke finishes doing operations. This count can be enormous, so compute it modulo (10^9+7).
Constraints
* 1 \leq N \leq 5000
* 1 \leq A,B \leq N
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N A B
Output
Print the number of different strings that x can be after Snuke finishes doing operations, modulo (10^9+7).
Examples
Input
4 2 3
Output
11
Input
10 7 2
Output
533
Input
1000 100 10
Output
828178524
### Response
```cpp
#include <cstdio>
#include <algorithm>
using namespace std;
const int mod = 1000000007;
int dp[5001];
int dp2[5001];
int dp3[5001][2];
int main() {
int n, a, b, ans, i, j, k;
scanf("%d %d %d", &n, &a, &b);
if (a > b) swap(a, b);
dp[1] = 1;
for (i = 1; i < n; i++) {
dp[i + 1] += dp[i];
if (dp[i + 1] >= mod) dp[i + 1] -= mod;
for (j = a + 1; i + j <= n; j++) {
dp[i + j] += dp[i];
if (dp[i + j] >= mod) dp[i + j] -= mod;
}
}
dp2[0] = 1;
for (i = 0; i < n; i++) {
dp2[i + 1] += dp2[i];
if (dp2[i + 1] >= mod) dp2[i + 1] -= mod;
for (j = a + 1; i + j <= n; j++) {
dp2[i + j] += dp2[i];
if (dp2[i + j] >= mod) dp2[i + j] -= mod;
}
}
for (i = 0; i < b; i++) dp3[i][1] = dp2[i];
for (i = 0; i < n; i++) {
for (j = 0; j < 2; j++) {
if (dp3[i][j] == 0) continue;
if (j != 0) {
for (k = 1; k < a && i + k <= n; k++) {
dp3[i + k][0] += dp3[i][j];
if (dp3[i + k][0] >= mod) dp3[i + k][0] -= mod;
}
}
if (j != 1) {
for (k = 1; k < b && i + k < n; k++) {
dp3[i + k][1] += (long long)dp3[i][j] * dp[k] % mod;
if (dp3[i + k][1] >= mod) dp3[i + k][1] -= mod;
}
if (n - i < b) {
dp3[n][1] += (long long)dp3[i][j] * dp2[n - i] % mod;
if (dp3[n][1] >= mod) dp3[n][1] -= mod;
}
}
}
}
ans = 1;
for (i = 0; i < n; i++) ans = ans * 2 % mod;
for (i = 0; i < 2; i++) {
ans -= dp3[n][i];
if (ans < 0) ans += mod;
}
printf("%d\n", ans);
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
The only difference between easy and hard versions is the length of the string.
You are given a string s and a string t, both consisting only of lowercase Latin letters. It is guaranteed that t can be obtained from s by removing some (possibly, zero) number of characters (not necessary contiguous) from s without changing order of remaining characters (in other words, it is guaranteed that t is a subsequence of s).
For example, the strings "test", "tst", "tt", "et" and "" are subsequences of the string "test". But the strings "tset", "se", "contest" are not subsequences of the string "test".
You want to remove some substring (contiguous subsequence) from s of maximum possible length such that after removing this substring t will remain a subsequence of s.
If you want to remove the substring s[l;r] then the string s will be transformed to s_1 s_2 ... s_{l-1} s_{r+1} s_{r+2} ... s_{|s|-1} s_{|s|} (where |s| is the length of s).
Your task is to find the maximum possible length of the substring you can remove so that t is still a subsequence of s.
Input
The first line of the input contains one string s consisting of at least 1 and at most 2 ⋅ 10^5 lowercase Latin letters.
The second line of the input contains one string t consisting of at least 1 and at most 2 ⋅ 10^5 lowercase Latin letters.
It is guaranteed that t is a subsequence of s.
Output
Print one integer — the maximum possible length of the substring you can remove so that t is still a subsequence of s.
Examples
Input
bbaba
bb
Output
3
Input
baaba
ab
Output
2
Input
abcde
abcde
Output
0
Input
asdfasdf
fasd
Output
3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const string nl = "\n";
const long long MOD = 1000000007;
int main() {
string s, t;
cin >> s >> t;
int n = s.size(), m = t.size();
int j = m - 1;
long long frnt[n], bck[n];
long long cnt = 0;
for (int i = n - 1; i >= 0; i--) {
bck[i] = cnt;
if (s[i] == t[j]) {
cnt++;
j--;
}
}
j = 0;
cnt = 0;
for (int i = 0; i < n; i++) {
frnt[i] = cnt;
if (s[i] == t[j]) {
cnt++;
j++;
}
}
int i = 0;
j = 0;
int mx = 0;
while ((i < n) && (j < n)) {
if (frnt[i] + bck[j] >= m) {
j++;
} else {
mx = max(mx, j - i);
if (i == j) j++;
i++;
}
}
mx = max(n - i, mx);
cout << mx;
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
Permutation p is an ordered set of integers p1, p2, ..., pn, consisting of n distinct positive integers, each of them doesn't exceed n. We'll denote the i-th element of permutation p as pi. We'll call number n the size or the length of permutation p1, p2, ..., pn.
We'll call position i (1 ≤ i ≤ n) in permutation p1, p2, ..., pn good, if |p[i] - i| = 1. Count the number of permutations of size n with exactly k good positions. Print the answer modulo 1000000007 (109 + 7).
Input
The single line contains two space-separated integers n and k (1 ≤ n ≤ 1000, 0 ≤ k ≤ n).
Output
Print the number of permutations of length n with exactly k good positions modulo 1000000007 (109 + 7).
Examples
Input
1 0
Output
1
Input
2 1
Output
0
Input
3 2
Output
4
Input
4 1
Output
6
Input
7 4
Output
328
Note
The only permutation of size 1 has 0 good positions.
Permutation (1, 2) has 0 good positions, and permutation (2, 1) has 2 positions.
Permutations of size 3:
1. (1, 2, 3) — 0 positions
2. <image> — 2 positions
3. <image> — 2 positions
4. <image> — 2 positions
5. <image> — 2 positions
6. (3, 2, 1) — 0 positions
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const double eps = 1e-8;
const int maxn = 1e3 + 5;
const long long mod = 1e9 + 7;
inline long long read() {
long long ans = 0;
char ch = getchar(), last = ' ';
while (!isdigit(ch)) last = ch, ch = getchar();
while (isdigit(ch)) ans = (ans << 1) + (ans << 3) + ch - '0', ch = getchar();
if (last == '-') ans = -ans;
return ans;
}
inline void write(long long x) {
if (x < 0) x = -x, putchar('-');
if (x >= 10) write(x / 10);
putchar(x % 10 + '0');
}
inline void MYFILE() {
freopen("ha.in", "r", stdin);
freopen("ha.out", "w", stdout);
}
int n, m;
long long dp[maxn][maxn][2][2], ans[maxn];
inline long long inc(long long a, long long b) {
return a + b < mod ? a + b : a + b - mod;
}
long long fac[maxn], C[maxn][maxn];
inline void init() {
fac[0] = 1;
for (int i = 1; i < maxn; ++i) fac[i] = fac[i - 1] * i % mod;
C[0][0] = 1;
for (int i = 1; i < maxn; ++i) {
C[i][0] = 1;
for (int j = 1; j <= i; ++j) C[i][j] = inc(C[i - 1][j - 1], C[i - 1][j]);
}
}
int main() {
n = read(), m = read();
init();
dp[0][0][1][0] = 1;
for (int i = 1; i <= n; ++i)
for (int j = 0; j < i; ++j)
for (int k = 0; k < 2; ++k)
for (int h = 0; h < 2; ++h) {
dp[i][j][h][0] = inc(dp[i][j][h][0], dp[i - 1][j][k][h]);
if (!k)
dp[i][j + 1][h][0] = inc(dp[i][j + 1][h][0], dp[i - 1][j][k][h]);
if (i < n)
dp[i][j + 1][h][1] = inc(dp[i][j + 1][h][1], dp[i - 1][j][k][h]);
}
for (int i = 0; i <= n; ++i) {
for (int k = 0; k < 2; ++k)
for (int h = 0; h < 2; ++h) ans[i] = inc(ans[i], dp[n][i][k][h]);
ans[i] = ans[i] * fac[n - i] % mod;
}
for (int i = m + 1; i <= n; ++i) {
long long tp = C[i][m] * ans[i] % mod;
ans[m] = inc(ans[m], ((i - m) & 1) ? mod - tp : tp);
}
write(ans[m]), puts("");
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
Your task is to write a program which reads an expression and evaluates it.
* The expression consists of numerical values, operators and parentheses, and the ends with '='.
* The operators includes +, - , *, / where respectively represents, addition, subtraction, multiplication and division.
* Precedence of the operators is based on usual laws. That is one should perform all multiplication and division first, then addition and subtraction. When two operators have the same precedence, they are applied from left to right.
* You may assume that there is no division by zero.
* All calculation is performed as integers, and after the decimal point should be truncated
* Length of the expression will not exceed 100.
* -1 × 109 ≤ intermediate results of computation ≤ 109
Input
The input is a sequence of datasets. The first line contains an integer n which represents the number of datasets. There will be n lines where each line contains an expression.
Output
For each datasets, prints the result of calculation.
Example
Input
2
4-2*3=
4*(8+4+3)=
Output
-2
60
### Response
```cpp
#include <iostream>
#include <string>
using namespace std;
int hyoka(string);
int isNum(int);
int main(){
int n,i;
string s;
cin>>n;
for(i=0;i<n;i++){
cin>>s;
cout<<hyoka(s)<<endl;
}
return 0;
}
int hyoka(string s){
long int total=0,work=0;
long int tmp1,tmp2;
int oi=0;
char oc;
int n;
string cs;
if(s[oi]=='(' || isNum(s[oi])!=-1){s="+"+s;}
//cout<<s<<endl;
while(1){
oc=s[oi];if(oc=='='){total+=work;break;}
if(s[oi+1]!='('){ //??°???????????????
tmp1=0;
while(1){
oi++;
tmp2=isNum(s[oi]);
if(tmp2!=-1){tmp1=tmp1*10+tmp2;}else{break;}
}
}else{ //??????????????°
cs="";n=1;oi++;
while(1){
oi++;
switch(s[oi]){
case '(':n++;break;
case ')':n--;break;
}
if(n!=0){cs+=s[oi];}else{break;}
}
cs+='=';
//cout<<cs<<endl;
tmp1=hyoka(cs);
}
switch(oc){
case '+':total+=work;work=tmp1;break;
case '-':total+=work;work=-tmp1;break;
case '*':work*=tmp1;break;
case '/':work/=tmp1;break;
}
}
return total;
}
int isNum(int c){
if(48<=c && c<=57){
return c-48;
}
return -1;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 1, -1, 0, 0};
int dy[] = {0, 0, 0, 1, -1};
pair<int, int> sir[100 * 100];
pair<int, int> T[100][100];
queue<pair<int, int> > q;
int n, m, sol, k, t, D[100][100];
void go(int x, int y) {
if (x == 1 && y == 1) {
cout << "(1,1) ";
return;
}
go(T[x][y].first, T[x][y].second);
cout << "(" << x << "," << y << ") ";
}
void bfs(int x, int y) {
q.push(make_pair(x, y));
D[x][y] = 1;
while (!q.empty()) {
pair<int, int> a = q.front();
q.pop();
sir[++t] = a;
if (t == k) return;
for (int i = 1; i <= 4; ++i) {
x = a.first + dx[i];
y = a.second + dy[i];
if (x < 1 || x > n || y < 1 || y > m) continue;
if (D[x][y]) continue;
D[x][y] = D[a.first][a.second] + 1;
T[x][y] = make_pair(a.first, a.second);
q.push(make_pair(x, y));
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m >> k;
bfs(1, 1);
for (int i = 1; i <= k; ++i) sol += D[sir[i].first][sir[i].second];
cout << sol << "\n";
for (int i = k; i >= 1; --i) {
go(sir[i].first, sir[i].second);
cout << "\n";
}
return 0;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
Let's call a number k-good if it contains all digits not exceeding k (0, ..., k). You've got a number k and an array a containing n numbers. Find out how many k-good numbers are in a (count each number every time it occurs in array a).
Input
The first line contains integers n and k (1 ≤ n ≤ 100, 0 ≤ k ≤ 9). The i-th of the following n lines contains integer ai without leading zeroes (1 ≤ ai ≤ 109).
Output
Print a single integer — the number of k-good numbers in a.
Examples
Input
10 6
1234560
1234560
1234560
1234560
1234560
1234560
1234560
1234560
1234560
1234560
Output
10
Input
2 1
1
10
Output
1
### Response
```cpp
#include <bits/stdc++.h>
char L[11];
int k, l, n, ok, C[10];
int main() {
scanf("%d %d", &n, &k);
while (n--) {
memset(C, 0, sizeof(C));
scanf("%s", L);
for (int i = 0; L[i]; i++) {
C[L[i] - '0'] = 1;
}
ok = 1;
for (int i = 0; i <= k; i++) {
if (!C[i]) {
ok = 0;
break;
}
}
if (ok) l++;
}
printf("%d\n", l);
return 0;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
Polycarp's phone book contains n phone numbers, each of them is described by s_i — the number itself and m_i — the number of times Polycarp dials it in daily.
Polycarp has just bought a brand new phone with an amazing speed dial feature! More precisely, k buttons on it can have a number assigned to it (not necessary from the phone book). To enter some number Polycarp can press one of these k buttons and then finish the number using usual digit buttons (entering a number with only digit buttons is also possible).
Speed dial button can only be used when no digits are entered. No button can have its number reassigned.
What is the minimal total number of digit number presses Polycarp can achieve after he assigns numbers to speed dial buttons and enters each of the numbers from his phone book the given number of times in an optimal way?
Input
The first line contains two integers n and k (1 ≤ n ≤ 500, 1 ≤ k ≤ 10) — the amount of numbers in Polycarp's phone book and the number of speed dial buttons his new phone has.
The i-th of the next n lines contain a string s_i and an integer m_i (1 ≤ m_i ≤ 500), where s_i is a non-empty string of digits from 0 to 9 inclusive (the i-th number), and m_i is the amount of times it will be dialed, respectively.
It is guaranteed that the total length of all phone numbers will not exceed 500.
Output
Print a single integer — the minimal total number of digit number presses Polycarp can achieve after he assigns numbers to speed dial buttons and enters each of the numbers from his phone book the given number of times in an optimal way.
Examples
Input
3 1
0001 5
001 4
01 1
Output
14
Input
3 1
0001 5
001 6
01 1
Output
18
Note
The only speed dial button in the first example should have "0001" on it. The total number of digit button presses will be 0 ⋅ 5 for the first number + 3 ⋅ 4 for the second + 2 ⋅ 1 for the third. 14 in total.
The only speed dial button in the second example should have "00" on it. The total number of digit button presses will be 2 ⋅ 5 for the first number + 1 ⋅ 6 for the second + 2 ⋅ 1 for the third. 18 in total.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 510;
int n, K, f[N][N][20], val[N], fa[N][N], ans = 0, cnt = 1;
int nxt[N][12], v[N], siz[N], tmp[N][12], dep[N];
char str[N];
void dfs(int u) {
fa[u][0] = u;
siz[u] = 1;
for (int i = 0; i <= dep[u]; i++) f[u][i][!i] = dep[fa[u][i]] * v[u];
for (int i = 0; i < 10; i++)
if (nxt[u][i]) {
int v = nxt[u][i];
dep[v] = dep[u] + 1;
for (int j = 0; j <= dep[u]; j++) fa[v][j + 1] = fa[u][j];
dfs(v);
for (int j = 0; j <= dep[u]; j++) {
for (int k = 0; k <= siz[u] && k <= K; k++) {
tmp[j][k] = f[u][j][k];
f[u][j][k] = -0x7ffffff;
}
}
for (int j = 0; j <= dep[u]; j++) {
for (int k = 0; k <= siz[u] && k <= K; k++) {
for (int l = 0; l <= siz[v] && l + k <= K; l++) {
f[u][j][k + l] = max(f[u][j][k + l],
tmp[j][k] + max(f[v][j + 1][l], f[v][0][l]));
}
}
}
siz[u] += siz[v];
}
}
int main() {
memset(f, 0xc0, sizeof(f));
scanf("%d%d", &n, &K);
K++;
for (int i = 1, l, p; i <= n; i++) {
scanf("%s%d", str + 1, &val[i]);
l = strlen(str + 1);
ans += l * val[i];
p = 1;
for (int j = 1; j <= l; j++) {
int &k = nxt[p][str[j] - '0'];
if (!k) k = ++cnt;
p = k;
}
v[p] += val[i];
}
dfs(1);
int mx = 0;
for (int i = 1; i <= K; i++) mx = max(mx, f[1][0][i]);
printf("%d\n", ans - mx);
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
A permutation p of size n is an array such that every integer from 1 to n occurs exactly once in this array.
Let's call a permutation an almost identity permutation iff there exist at least n - k indices i (1 ≤ i ≤ n) such that pi = i.
Your task is to count the number of almost identity permutations for given numbers n and k.
Input
The first line contains two integers n and k (4 ≤ n ≤ 1000, 1 ≤ k ≤ 4).
Output
Print the number of almost identity permutations for given n and k.
Examples
Input
4 1
Output
1
Input
4 2
Output
7
Input
5 3
Output
31
Input
5 4
Output
76
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long Det[20000];
long long C[2000];
void det() {
Det[0] = 1;
Det[1] = 0;
Det[2] = 1;
for (long long i = 3; i <= 10009; i++) {
Det[i] = (i - 1) * (Det[i - 1] + Det[i - 2]);
}
}
long long binomialCoeff(long long n, long long k) {
memset(C, 0, sizeof(C));
C[0] = 1;
for (long long i = 1; i <= n; i++) {
for (long long j = min(i, k); j > 0; j--) C[j] = C[j] + C[j - 1];
}
return C[k];
}
int main() {
long long i, j, k, l, m, n, ans = 0;
det();
cin >> n >> k;
m = n - k;
for (i = m; i <= n; i++) {
ans += (binomialCoeff(n, i) * Det[n - i]);
}
cout << ans << endl;
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
Description
THE BY DOLM @ STER is a training simulation game scheduled to be released on EXIDNA by 1rem on April 1, 2010. For the time being, it probably has nothing to do with an arcade game where the network connection service stopped earlier this month.
This game is a game in which members of the unit (formation) to be produced are selected from the bidders, and through lessons and communication with the members, they (they) are raised to the top of the bidders, the top biddles.
Each bidle has three parameters, vocal, dance, and looks, and the unit's ability score is the sum of all the parameters of the biddles that belong to the unit. The highest of the three stats of a unit is the rank of the unit.
There is no limit to the number of people in a unit, and you can work as a unit with one, three, or 100 members. Of course, you can hire more than one of the same bidle, but hiring a bidle is expensive and must be taken into account.
As a producer, you decided to write and calculate a program to make the best unit.
Input
The input consists of multiple test cases.
The first line of each test case is given the number N of bid dollars and the available cost M. (1 <= N, M <= 300) The next 2 * N lines contain information about each bidle.
The name of the bidle is on the first line of the bidle information. Biddle names consist of alphabets and spaces, with 30 characters or less. Also, there is no bidle with the same name.
The second line is given the integers C, V, D, L. C is the cost of hiring one Biddle, V is the vocal, D is the dance, and L is the stat of the looks. (1 <= C, V, D, L <= 300)
Input ends with EOF.
Output
Answer the maximum rank of units that can be made within the given cost.
If you cannot make a unit, output 0.
Example
Input
3 10
Dobkeradops
7 5 23 10
PataPata
1 1 2 1
dop
5 3 11 14
2 300
Bydo System Alpha
7 11 4 7
Green Inferno
300 300 300 300
Output
29
462
### Response
```cpp
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <cstring>
#define FOR(i, a, b) for(int i = (a); i < (b); i++)
#define rep(i, n) FOR(i, 0, n)
#define MP make_pair
using namespace std;
typedef pair<int, int> P;
int dp[500];
int main(){
int n, m;
while(cin >> n >> m){
vector<int> c(n);
vector<vector<int> > v(3, vector<int>(n));
rep(i, n){
cin.ignore();
string s;
getline(cin, s);
cin >> c[i] >> v[0][i] >> v[1][i] >> v[2][i];
}
int ans = 0;
rep(j, 3){
memset(dp, -1, sizeof(dp));
dp[0] = 0;
for(int k = 0; k < n; k++){
for(int i = c[k]; i <= m; i++){
if(dp[i-c[k]] != -1) dp[i] = max(dp[i], dp[i-c[k]]+v[j][k]);
}
}
ans = max(ans, *max_element(dp, dp+500));
}
cout << ans << endl;
}
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
The board has got a painted tree graph, consisting of n nodes. Let us remind you that a non-directed graph is called a tree if it is connected and doesn't contain any cycles.
Each node of the graph is painted black or white in such a manner that there aren't two nodes of the same color, connected by an edge. Each edge contains its value written on it as a non-negative integer.
A bad boy Vasya came up to the board and wrote number sv near each node v — the sum of values of all edges that are incident to this node. Then Vasya removed the edges and their values from the board.
Your task is to restore the original tree by the node colors and numbers sv.
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 105) — the number of nodes in the tree. Next n lines contain pairs of space-separated integers ci, si (0 ≤ ci ≤ 1, 0 ≤ si ≤ 109), where ci stands for the color of the i-th vertex (0 is for white, 1 is for black), and si represents the sum of values of the edges that are incident to the i-th vertex of the tree that is painted on the board.
Output
Print the description of n - 1 edges of the tree graph. Each description is a group of three integers vi, ui, wi (1 ≤ vi, ui ≤ n, vi ≠ ui, 0 ≤ wi ≤ 109), where vi and ui — are the numbers of the nodes that are connected by the i-th edge, and wi is its value. Note that the following condition must fulfill cvi ≠ cui.
It is guaranteed that for any input data there exists at least one graph that meets these data. If there are multiple solutions, print any of them. You are allowed to print the edges in any order. As you print the numbers, separate them with spaces.
Examples
Input
3
1 3
1 2
0 5
Output
3 1 3
3 2 2
Input
6
1 0
0 3
1 8
0 2
0 3
0 0
Output
2 3 3
5 3 3
4 3 2
1 6 0
2 1 0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
struct var {
long long x, y, wt;
};
signed main(void) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
priority_queue<pair<long long, long long>, vector<pair<long long, long long>>,
greater<pair<long long, long long>>>
pq1, pq2;
long long t = 1;
while (t--) {
long long n;
cin >> n;
for (long long i = 0; i < n; i++) {
long long c, s;
cin >> c >> s;
if (c == 0) {
pq1.push({s, i + 1});
} else {
pq2.push({s, i + 1});
}
}
long long rem = 0;
long long val = 0;
pair<long long, long long> x1, y1, prev_x1;
prev_x1 = {0, 0};
vector<var> v1;
while (!pq1.empty() || !pq2.empty()) {
long long flag = 0;
if (rem == 0) {
if (!pq1.empty()) {
flag++;
x1 = pq1.top();
pq1.pop();
rem = x1.first;
}
}
if (val == 0) {
if (!pq2.empty()) {
flag++;
y1 = pq2.top();
pq2.pop();
val = y1.first;
}
}
if (flag == 2 && prev_x1.second != 0) {
v1.push_back({prev_x1.second, y1.second, 0});
}
long long temp = min(val, rem);
val -= temp;
rem -= temp;
prev_x1 = x1;
v1.push_back({x1.second, y1.second, temp});
}
for (auto p : v1) {
cout << p.x << " " << p.y << " " << p.wt << '\n';
}
}
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
Square1001 has seen an electric bulletin board displaying the integer 1. He can perform the following operations A and B to change this value:
* Operation A: The displayed value is doubled.
* Operation B: The displayed value increases by K.
Square1001 needs to perform these operations N times in total. Find the minimum possible value displayed in the board after N operations.
Constraints
* 1 \leq N, K \leq 10
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
K
Output
Print the minimum possible value displayed in the board after N operations.
Examples
Input
4
3
Output
10
Input
10
10
Output
76
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
int ans=1,n,k;
cin>>n>>k;
for(int i=1;i<=n;i++){
ans+=min(ans,k);
}
cout<<ans<<endl;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
Little Johnny has recently learned about set theory. Now he is studying binary relations. You've probably heard the term "equivalence relation". These relations are very important in many areas of mathematics. For example, the equality of the two numbers is an equivalence relation.
A set ρ of pairs (a, b) of elements of some set A is called a binary relation on set A. For two elements a and b of the set A we say that they are in relation ρ, if pair <image>, in this case we use a notation <image>.
Binary relation is equivalence relation, if:
1. It is reflexive (for any a it is true that <image>);
2. It is symmetric (for any a, b it is true that if <image>, then <image>);
3. It is transitive (if <image> and <image>, than <image>).
Little Johnny is not completely a fool and he noticed that the first condition is not necessary! Here is his "proof":
Take any two elements, a and b. If <image>, then <image> (according to property (2)), which means <image> (according to property (3)).
It's very simple, isn't it? However, you noticed that Johnny's "proof" is wrong, and decided to show him a lot of examples that prove him wrong.
Here's your task: count the number of binary relations over a set of size n such that they are symmetric, transitive, but not an equivalence relations (i.e. they are not reflexive).
Since their number may be very large (not 0, according to Little Johnny), print the remainder of integer division of this number by 109 + 7.
Input
A single line contains a single integer n (1 ≤ n ≤ 4000).
Output
In a single line print the answer to the problem modulo 109 + 7.
Examples
Input
1
Output
1
Input
2
Output
3
Input
3
Output
10
Note
If n = 1 there is only one such relation — an empty one, i.e. <image>. In other words, for a single element x of set A the following is hold: <image>.
If n = 2 there are three such relations. Let's assume that set A consists of two elements, x and y. Then the valid relations are <image>, ρ = {(x, x)}, ρ = {(y, y)}. It is easy to see that the three listed binary relations are symmetric and transitive relations, but they are not equivalence relations.
### Response
```cpp
#include <bits/stdc++.h>
#pragma GCC target("avx2,avx")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
using namespace std;
using ll = long long;
using ull = unsigned long long;
using i128 = __int128_t;
using pii = pair<int, int>;
using pll = pair<long long, long long>;
constexpr char ln = '\n';
istream& operator>>(istream& is, __int128_t& x) {
x = 0;
string s;
is >> s;
int n = int(s.size()), it = 0;
if (s[0] == '-') it++;
for (; it < n; it++) x = (x * 10 + s[it] - '0');
if (s[0] == '-') x = -x;
return is;
}
ostream& operator<<(ostream& os, __int128_t x) {
if (x == 0) return os << 0;
if (x < 0) os << '-', x = -x;
deque<int> deq;
while (x) deq.emplace_front(x % 10), x /= 10;
for (int e : deq) os << e;
return os;
}
template <class T1, class T2>
ostream& operator<<(ostream& os, const pair<T1, T2>& p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& v) {
os << "{";
for (int i = 0; i < int(v.size()); i++) {
if (i) os << ", ";
os << v[i];
}
return os << "}";
}
template <class Container>
inline int SZ(Container& v) {
return int(v.size());
}
template <class T>
inline void UNIQUE(vector<T>& v) {
v.erase(unique(v.begin(), v.end()), v.end());
}
template <class T1, class T2>
inline bool chmax(T1& a, T2 b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T1, class T2>
inline bool chmin(T1& a, T2 b) {
if (a > b) {
a = b;
return true;
}
return false;
}
inline int topbit(int x) { return x == 0 ? -1 : 31 - __builtin_clz(x); }
inline int topbit(long long x) { return x == 0 ? -1 : 63 - __builtin_clzll(x); }
inline int botbit(int x) { return x == 0 ? 32 : __builtin_ctz(x); }
inline int botbit(long long x) { return x == 0 ? 64 : __builtin_ctzll(x); }
inline int popcount(int x) { return __builtin_popcount(x); }
inline int popcount(long long x) { return __builtin_popcountll(x); }
inline int kthbit(long long x, int k) { return (x >> k) & 1; }
inline constexpr long long TEN(int x) { return x == 0 ? 1 : TEN(x - 1) * 10; }
inline void print() { cout << "\n"; }
template <class T>
inline void print(const vector<T>& v) {
for (int i = 0; i < int(v.size()); i++) {
if (i) cout << " ";
cout << v[i];
}
print();
}
template <class T, class... Args>
inline void print(const T& x, const Args&... args) {
cout << x << " ";
print(args...);
}
struct fast_ios {
fast_ios() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
};
} fast_ios_;
template <int m>
struct ModInt {
public:
static constexpr int mod() { return m; }
static ModInt raw(int v) {
ModInt x;
x._v = v;
return x;
}
ModInt() : _v(0) {}
ModInt(long long v) {
long long x = (long long)(v % (long long)(umod()));
if (x < 0) x += umod();
_v = (unsigned int)(x);
}
unsigned int val() const { return _v; }
ModInt& operator++() {
_v++;
if (_v == umod()) _v = 0;
return *this;
}
ModInt& operator--() {
if (_v == 0) _v = umod();
_v--;
return *this;
}
ModInt operator++(int) {
ModInt result = *this;
++*this;
return result;
}
ModInt operator--(int) {
ModInt result = *this;
--*this;
return result;
}
ModInt& operator+=(const ModInt& rhs) {
_v += rhs._v;
if (_v >= umod()) _v -= umod();
return *this;
}
ModInt& operator-=(const ModInt& rhs) {
_v -= rhs._v;
if (_v >= umod()) _v += umod();
return *this;
}
ModInt& operator*=(const ModInt& rhs) {
unsigned long long z = _v;
z *= rhs._v;
_v = (unsigned int)(z % umod());
return *this;
}
ModInt& operator^=(long long n) {
ModInt x = *this;
*this = 1;
if (n < 0) x = x.inv(), n = -n;
while (n) {
if (n & 1) *this *= x;
x *= x;
n >>= 1;
}
return *this;
}
ModInt& operator/=(const ModInt& rhs) { return *this = *this * rhs.inv(); }
ModInt operator+() const { return *this; }
ModInt operator-() const { return ModInt() - *this; }
ModInt pow(long long n) const {
ModInt r = *this;
r ^= n;
return r;
}
ModInt inv() const {
int a = _v, b = umod(), y = 1, z = 0, t;
for (;;) {
t = a / b;
a -= t * b;
if (a == 0) {
assert(b == 1 || b == -1);
return ModInt(b * z);
}
y -= t * z;
t = b / a;
b -= t * a;
if (b == 0) {
assert(a == 1 || a == -1);
return ModInt(a * y);
}
z -= t * y;
}
}
friend ModInt operator+(const ModInt& lhs, const ModInt& rhs) {
return ModInt(lhs) += rhs;
}
friend ModInt operator-(const ModInt& lhs, const ModInt& rhs) {
return ModInt(lhs) -= rhs;
}
friend ModInt operator*(const ModInt& lhs, const ModInt& rhs) {
return ModInt(lhs) *= rhs;
}
friend ModInt operator/(const ModInt& lhs, const ModInt& rhs) {
return ModInt(lhs) /= rhs;
}
friend ModInt operator^(const ModInt& lhs, long long rhs) {
return ModInt(lhs) ^= rhs;
}
friend bool operator==(const ModInt& lhs, const ModInt& rhs) {
return lhs._v == rhs._v;
}
friend bool operator!=(const ModInt& lhs, const ModInt& rhs) {
return lhs._v != rhs._v;
}
friend ModInt operator+(long long lhs, const ModInt& rhs) {
return (ModInt(lhs) += rhs);
}
friend ModInt operator-(long long lhs, const ModInt& rhs) {
return (ModInt(lhs) -= rhs);
}
friend ModInt operator*(long long lhs, const ModInt& rhs) {
return (ModInt(lhs) *= rhs);
}
friend ostream& operator<<(ostream& os, const ModInt& rhs) {
return os << rhs._v;
}
private:
unsigned int _v;
static constexpr unsigned int umod() { return m; }
};
constexpr int MOD = 1000000007;
using mint = ModInt<MOD>;
struct ModCombination {
vector<mint> Fac, Facinv;
ModCombination(int x) {
Fac.resize(x + 1);
Facinv.resize(x + 1);
Fac[0] = 1;
for (int i = 0; i < x; ++i) Fac[i + 1] = Fac[i] * (i + 1);
Facinv[x] = Fac[0] / Fac[x];
for (int i = x; i > 0; --i) Facinv[i - 1] = Facinv[i] * i;
}
mint get(int n, int k) {
if (k < 0 || k > n) return 0;
return Fac[n] * Facinv[k] * Facinv[n - k];
}
};
int main() {
int N;
cin >> N;
ModCombination MC(100000);
vector<vector<mint>> dp(N + 1, vector<mint>(N + 1));
dp[0][0] = 1;
for (int i = 0; i < (N); i++) {
for (int j = 0; j < (N + 1); j++) {
dp[i + 1][j] += dp[i][j] * j;
if (j < N) dp[i + 1][j + 1] += dp[i][j];
}
}
mint ans = 0;
for (int i = 0; i < (N); i++)
for (int j = 0; j < (i + 1); j++) ans += dp[i][j] * MC.get(N, i);
cout << ans << ln;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
There are n piles of stones, where the i-th pile has a_i stones. Two people play a game, where they take alternating turns removing stones.
In a move, a player may remove a positive number of stones from the first non-empty pile (the pile with the minimal index, that has at least one stone). The first player who cannot make a move (because all piles are empty) loses the game. If both players play optimally, determine the winner of the game.
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 10^5) — the number of piles.
The second line of each test case contains n integers a_1,…,a_n (1≤ a_i≤ 10^9) — a_i is equal to the number of stones in the i-th pile.
It is guaranteed that the sum of n for all test cases does not exceed 10^5.
Output
For each test case, if the player who makes the first move will win, output "First". Otherwise, output "Second".
Example
Input
7
3
2 5 4
8
1 1 1 1 1 1 1 1
6
1 2 3 4 5 6
6
1 1 2 1 2 2
1
1000000000
5
1 2 2 1 1
3
1 1 1
Output
First
Second
Second
First
First
Second
First
Note
In the first test case, the first player will win the game. His winning strategy is:
1. The first player should take the stones from the first pile. He will take 1 stone. The numbers of stones in piles will be [1, 5, 4].
2. The second player should take the stones from the first pile. He will take 1 stone because he can't take any other number of stones. The numbers of stones in piles will be [0, 5, 4].
3. The first player should take the stones from the second pile because the first pile is empty. He will take 4 stones. The numbers of stones in piles will be [0, 1, 4].
4. The second player should take the stones from the second pile because the first pile is empty. He will take 1 stone because he can't take any other number of stones. The numbers of stones in piles will be [0, 0, 4].
5. The first player should take the stones from the third pile because the first and second piles are empty. He will take 4 stones. The numbers of stones in piles will be [0, 0, 0].
6. The second player will lose the game because all piles will be empty.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b = 0, c = 0, n, t;
cin >> t;
for (int o = 1; o <= t; o++) {
b = 0;
c = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a;
if (a != 1) {
c = 1;
} else {
if (c == 0) {
b = b + 1;
}
}
}
if (n == 1) {
cout << "First";
} else {
if (c == 0) {
if (n % 2 == 0) {
cout << "Second";
} else {
cout << "First";
}
} else {
if (b % 2 == 0) {
cout << "First";
} else {
cout << "Second";
}
}
}
cout << endl;
}
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
Ostap already settled down in Rio de Janiero suburb and started to grow a tree in his garden. Recall that a tree is a connected undirected acyclic graph.
Ostap's tree now has n vertices. He wants to paint some vertices of the tree black such that from any vertex u there is at least one black vertex v at distance no more than k. Distance between two vertices of the tree is the minimum possible number of edges of the path between them.
As this number of ways to paint the tree can be large, Ostap wants you to compute it modulo 109 + 7. Two ways to paint the tree are considered different if there exists a vertex that is painted black in one way and is not painted in the other one.
Input
The first line of the input contains two integers n and k (1 ≤ n ≤ 100, 0 ≤ k ≤ min(20, n - 1)) — the number of vertices in Ostap's tree and the maximum allowed distance to the nearest black vertex. Don't miss the unusual constraint for k.
Each of the next n - 1 lines contain two integers ui and vi (1 ≤ ui, vi ≤ n) — indices of vertices, connected by the i-th edge. It's guaranteed that given graph is a tree.
Output
Print one integer — the remainder of division of the number of ways to paint the tree by 1 000 000 007 (109 + 7).
Examples
Input
2 0
1 2
Output
1
Input
2 1
1 2
Output
3
Input
4 1
1 2
2 3
3 4
Output
9
Input
7 2
1 2
2 3
1 4
4 5
1 6
6 7
Output
91
Note
In the first sample, Ostap has to paint both vertices black.
In the second sample, it is enough to paint only one of two vertices, thus the answer is 3: Ostap can paint only vertex 1, only vertex 2, vertices 1 and 2 both.
In the third sample, the valid ways to paint vertices are: {1, 3}, {1, 4}, {2, 3}, {2, 4}, {1, 2, 3}, {1, 2, 4}, {1, 3, 4}, {2, 3, 4}, {1, 2, 3, 4}.
### Response
```cpp
#include <bits/stdc++.h>
const int N = 110;
const int M = 30;
const int moder = (int)1e9 + 7;
int dp[N][M][M], sz[N], tmp[M][M];
int n, k;
std::vector<int> e[N];
inline void addmult(int &a, int b, int c) { a = (a + 1ll * b * c) % moder; }
inline void add(int &a, int b) {
a += b;
a -= a >= moder ? moder : 0;
}
inline void sub(int &a, int b) {
a -= b;
a += a < 0 ? moder : 0;
}
void dfs(int u, int fa) {
sz[u] = 1;
dp[u][0][0] = 1;
for (auto v : e[u]) {
if (v == fa) {
continue;
}
dfs(v, u);
memset(tmp, 0, sizeof(tmp));
for (int i = 0; i <= k && i <= sz[u]; ++i) {
for (int j = 0; j <= k && j <= sz[v]; ++j) {
for (int a = 0; a <= k && a <= sz[u]; ++a) {
if (dp[u][i][a] == 0 || (j > 0 && a > 0 && j + a <= k)) {
continue;
}
for (int b = 0; b <= k && b <= sz[v]; ++b) {
if (dp[v][j][b] == 0 || (i > 0 && b > 0 && i + b <= k)) {
continue;
}
int ni = i == 0 ? j : j == 0 ? i : std::min(i, j);
int nj = a == 0 ? b : b == 0 ? a : std::min(a, b);
addmult(tmp[ni][nj], dp[u][i][a], dp[v][j][b]);
}
}
}
}
memcpy(dp[u], tmp, sizeof(tmp));
sz[u] += sz[v];
}
memset(tmp, 0, sizeof(tmp));
for (int j = 0; j <= k; ++j) {
sub(tmp[0][1], dp[u][0][j]);
}
for (int i = 0; i <= k; ++i) {
add(tmp[1][0], dp[u][i][0]);
}
for (int i = 0; i <= k; ++i) {
for (int j = 0; j <= k; ++j) {
int ni = i == 0 || i == k ? 0 : i + 1;
int nj = j == 0 || j == k ? 0 : j + 1;
add(tmp[ni][nj], dp[u][i][j]);
}
}
memcpy(dp[u], tmp, sizeof(tmp));
}
int main() {
srand((unsigned)time(nullptr));
scanf("%d%d", &n, &k);
for (int i = 0, u, v; i < n - 1; ++i) {
scanf("%d%d", &u, &v);
e[u].push_back(v);
e[v].push_back(u);
}
int root = rand() % n + 1;
dfs(root, 0);
int sum = 0;
for (int i = 0; i <= k; ++i) {
for (int j = 0; j <= k; ++j) {
add(sum, dp[root][i][j]);
}
}
printf("%d\n", sum);
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
A lot of people associate Logo programming language with turtle graphics. In this case the turtle moves along the straight line and accepts commands "T" ("turn around") and "F" ("move 1 unit forward").
You are given a list of commands that will be given to the turtle. You have to change exactly n commands from the list (one command can be changed several times). How far from the starting point can the turtle move after it follows all the commands of the modified list?
Input
The first line of input contains a string commands — the original list of commands. The string commands contains between 1 and 100 characters, inclusive, and contains only characters "T" and "F".
The second line contains an integer n (1 ≤ n ≤ 50) — the number of commands you have to change in the list.
Output
Output the maximum distance from the starting point to the ending point of the turtle's path. The ending point of the turtle's path is turtle's coordinate after it follows all the commands of the modified list.
Examples
Input
FT
1
Output
2
Input
FFFTFFF
2
Output
6
Note
In the first example the best option is to change the second command ("T") to "F" — this way the turtle will cover a distance of 2 units.
In the second example you have to change two commands. One of the ways to cover maximal distance of 6 units is to change the fourth command and first or last one.
### Response
```cpp
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:65777216")
using namespace std;
string s;
int n;
int best = 0;
int a[111][55][211][3];
void go(int pos, int change, int x, int dx) {
if (a[pos][change][x + 100][dx + 1]) return;
a[pos][change][x + 100][dx + 1] = 1;
if (pos == s.size()) {
if (change == 0) best = max(best, abs(x));
return;
}
for (int i(0); i < (change + 1); i++) {
int val = (s[pos] == 'F');
if (i % 2) val ^= 1;
go(pos + 1, change - i, x + (val == 1 ? dx : 0), dx * (val == 0 ? -1 : 1));
}
}
int main() {
cin >> s >> n;
go(0, n, 0, 1);
cout << best << endl;
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
Nikita has a stack. A stack in this problem is a data structure that supports two operations. Operation push(x) puts an integer x on the top of the stack, and operation pop() deletes the top integer from the stack, i. e. the last added. If the stack is empty, then the operation pop() does nothing.
Nikita made m operations with the stack but forgot them. Now Nikita wants to remember them. He remembers them one by one, on the i-th step he remembers an operation he made pi-th. In other words, he remembers the operations in order of some permutation p1, p2, ..., pm. After each step Nikita wants to know what is the integer on the top of the stack after performing the operations he have already remembered, in the corresponding order. Help him!
Input
The first line contains the integer m (1 ≤ m ≤ 105) — the number of operations Nikita made.
The next m lines contain the operations Nikita remembers. The i-th line starts with two integers pi and ti (1 ≤ pi ≤ m, ti = 0 or ti = 1) — the index of operation he remembers on the step i, and the type of the operation. ti equals 0, if the operation is pop(), and 1, is the operation is push(x). If the operation is push(x), the line also contains the integer xi (1 ≤ xi ≤ 106) — the integer added to the stack.
It is guaranteed that each integer from 1 to m is present exactly once among integers pi.
Output
Print m integers. The integer i should equal the number on the top of the stack after performing all the operations Nikita remembered on the steps from 1 to i. If the stack is empty after performing all these operations, print -1.
Examples
Input
2
2 1 2
1 0
Output
2
2
Input
3
1 1 2
2 1 3
3 0
Output
2
3
2
Input
5
5 0
4 0
3 1 1
2 1 1
1 1 2
Output
-1
-1
-1
-1
2
Note
In the first example, after Nikita remembers the operation on the first step, the operation push(2) is the only operation, so the answer is 2. After he remembers the operation pop() which was done before push(2), answer stays the same.
In the second example, the operations are push(2), push(3) and pop(). Nikita remembers them in the order they were performed.
In the third example Nikita remembers the operations in the reversed order.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const bool D = 0;
struct Query {
int p, t, x;
friend istream &operator>>(istream &stream, Query &query) {
stream >> query.p >> query.t;
if (query.t == 1) {
stream >> query.x;
} else {
query.t = -1;
}
--query.p;
return stream;
}
friend ostream &operator<<(ostream &stream, Query &query) {
stream << query.p << " " << query.t;
if (query.t == 1) {
stream << " " << query.x;
}
return stream;
}
};
struct SegmentTree {
vector<int> tree, pushing;
void build(int n) {
tree.clear();
pushing.clear();
tree.resize(4 * n, 0);
pushing.resize(4 * n, 0);
}
void push(int v, int l, int r) {
if (l < r) {
tree[v * 2] += pushing[v];
tree[v * 2 + 1] += pushing[v];
pushing[v * 2] += pushing[v];
pushing[v * 2 + 1] += pushing[v];
}
pushing[v] = 0;
}
void update(int v, int tl, int tr, int l, int r, int x) {
push(v, tl, tr);
if (l > r) {
return;
}
if (tl == l && tr == r) {
tree[v] += x;
pushing[v] += x;
return;
}
int tm = (tl + tr) / 2;
update(v * 2, tl, tm, l, min(tm, r), x);
update(v * 2 + 1, tm + 1, tr, max(tm + 1, l), r, x);
tree[v] = max(tree[v * 2], tree[v * 2 + 1]);
}
int get(int v, int tl, int tr, int l, int r, int k) {
push(v, tl, tr);
if (l > r) {
return -1;
}
if (tree[v] < k) {
return -1;
}
if (tl == tr) {
return tl;
}
int tm = (tl + tr) / 2;
if (tree[v * 2 + 1] >= k) {
return get(v * 2 + 1, tm + 1, tr, max(tm + 1, l), r, k);
}
return get(v * 2, tl, tm, l, min(tm, r), k);
}
};
int n, position;
vector<int> values;
vector<Query> queries;
SegmentTree tr;
int main() {
cin >> n;
queries.resize(n);
values.resize(n);
for (int i = 0; i < n; ++i) {
cin >> queries[i];
if (D) {
cout << queries[i] << endl;
}
if (queries[i].t == 1) {
values[queries[i].p] = queries[i].x;
}
}
tr.build(n);
for (int i = 0; i < n; ++i) {
tr.update(1, 0, n - 1, 0, queries[i].p, queries[i].t);
position = tr.get(1, 0, n - 1, 0, n - 1, 1);
if (position == -1) {
cout << position << endl;
} else {
cout << values[position] << endl;
}
}
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
There is a weighted tree with n nodes and n-1 edges. The nodes are conveniently labeled from 1 to n. The weights are positive integers at most 100. Define the distance between two nodes to be the sum of edges on the unique path between the nodes. You would like to find the diameter of the tree. Diameter is the maximum distance between a pair of nodes.
Unfortunately, the tree isn't given to you, but you can ask some questions about it. In one question, you can specify two nonempty disjoint sets of nodes p and q, and the judge will return the maximum distance between a node in p and a node in q. In the words, maximum distance between x and y, where x ∈ p and y ∈ q. After asking not more than 9 questions, you must report the maximum distance between any pair of nodes.
Interaction
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 1 000). Description of the test cases follows.
The first line of each test case contains an integer n (2 ≤ n ≤ 100) — the number of nodes in the tree.
To ask a question, print "k_1\ k_2\ a_1\ a_2\ …\ a_{k_1}\ b_1\ b_2\ …\ b_{k_2}" (k_1, k_2 ≥ 1 and k_1+k_2 ≤ n). These two sets must be nonempty and disjoint. The judge will respond with a single integer max_{p,q} dist(a_p, b_q). If you ever get a result of -1 (because you printed an invalid query), exit immediately to avoid getting other verdicts.
After printing a query do not forget to output end of line and flush the output. Otherwise, you will get Idleness limit exceeded. To do this, use:
* fflush(stdout) or cout.flush() in C++;
* System.out.flush() in Java;
* flush(output) in Pascal;
* stdout.flush() in Python;
* see documentation for other languages.
When you are ready to answer, print "-1\ d", where d is the maximum shortest distance over all pairs of nodes.
You can only ask at most 9 questions per test case.
Hack Format
To hack, use the following format. Note that you can only hack with one test case.
The first line should contain a single integer t (t=1).
The second line should contain a single integer n (2 ≤ n ≤ 100).
Each of the next n-1 lines should contain three integers a_i, b_i, c_i (1≤ a_i, b_i≤ n, 1 ≤ c_i ≤ 100). This denotes an undirected edge between nodes a_i and b_i with weight c_i. These edges must form a tree.
Example
Input
2
5
9
6
10
9
10
2
99
Output
1 4 1 2 3 4 5
1 4 2 3 4 5 1
1 4 3 4 5 1 2
1 4 4 5 1 2 3
1 4 5 1 2 3 4
-1 10
1 1 1 2
-1 99
Note
In the first example, the first tree looks as follows: <image>
In the first question, we have p = {1}, and q = {2, 3, 4, 5}. The maximum distance between a node in p and a node in q is 9 (the distance between nodes 1 and 5).
The second tree is a tree with two nodes with an edge with weight 99 between them.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long int x;
long long int query(long long int x, long long int y) {
printf("1 %lld ", y - x + 1);
printf("1 ");
for (long long int i = x; i <= y; i++) printf("%lld ", i);
fflush(stdout);
long long int inp;
cin >> inp;
return inp;
}
int main() {
long long int n, i, j, k, y, t, m;
cin >> t;
while (t--) {
cin >> n;
long long int start = 2;
long long int end = n;
printf("1 %lld ", n - 1);
printf("1 ");
for (i = 2; i <= n; i++) printf("%lld ", i);
fflush(stdout);
cin >> x;
while (start < end) {
long long int mid = (start + end) / 2;
if (query(start, mid) == x) {
end = mid;
} else {
start = mid + 1;
}
}
printf("1 %lld ", n - 1);
printf("%lld ", start);
for (i = 1; i <= n; i++) {
if (i != start) printf("%lld ", i);
}
fflush(stdout);
cin >> x;
printf("-1 ");
cout << x << endl;
}
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
Background
The kindergarten attached to the University of Aizu is a kindergarten where children who love programming gather. Yu, one of the kindergarten children, loves rectangular blocks as much as programming. Yu-kun has been enthusiastic about making mountains with building blocks recently.
Yu-kun was playing with making mountains today, but since it is easy to make many mountains with the building blocks he has, today I thought about minimizing the number of mountains that can be made with all the building blocks. So Yu-kun decided to write a program to see if the number of mountains was really minimized after actually making a mountain using all the blocks.
Problem
You will be given the number of blocks you have and the information about the blocks, so find the minimum number of mountains you can make from them.
Building blocks are represented as rectangles on a plane, and the length and width of the rectangle are given as building block information (without considering the height of the building blocks).
A mountain is a stack of zero or more blocks on top of blocks. However, in order to stack another building block on top of the building block, the vertical and horizontal lengths of the upper building blocks must be less than the vertical and horizontal lengths of the lower building blocks, respectively. Only one building block can be placed directly on one building block.
When placing blocks, the length and width of the two blocks must be parallel (it is not allowed to stack them diagonally). You may rotate the building blocks and exchange the length and width.
For example, consider the state shown in Fig. 1. The rectangle represents the building block, the number to the left represents the vertical length of the building block, the number below represents the horizontal length, and the number in the upper left of the rectangle represents the building block number. In the initial state, there are 5 mountains.
By stacking as shown in Fig. 1, the number of mountains can be finally reduced to two.
Figure 1
Figure 1
Input
N
w0 h0
w1 h1
...
wN-1 hN-1
All inputs are integers.
N represents the number of blocks. (1 ≤ N ≤ 100)
wi and hi represent the horizontal and vertical lengths of building blocks, respectively. (1 ≤ wi, hi ≤ 109)
Output
Output the minimum number of piles that can be made using all blocks in one line.
Examples
Input
3
1 1
2 2
3 3
Output
1
Input
5
2 3
3 5
1 2
1 4
3 5
Output
2
Input
5
1 5
2 4
3 3
4 2
5 1
Output
5
Input
10
5 11
12 12
4 14
22 12
11 13
3 3
3 3
12 5
55 55
1 1
Output
3
### Response
```cpp
#include<bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define HUGE_NUM 99999999999999999
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;
#define NUM 205
struct Info{
int W,H;
};
int V; //頂点数
vector<int> G[NUM];
int match[NUM];
bool used[NUM];
Info info[105];
void add_edge(int from,int to){
G[from].push_back(to);
G[to].push_back(from);
}
int dfs(int node_id){
used[node_id] = true;
for(int i = 0; i < G[node_id].size(); i++){
int adj_node_id = G[node_id][i],pair_id = match[adj_node_id];
if((pair_id < 0)||
(used[pair_id] == false && dfs(pair_id) == true)){
match[node_id] = adj_node_id;
match[adj_node_id] = node_id;
return true;
}
}
return false;
}
int bipartie_matching(){
int ret = 0;
for(int i = 0; i < V; i++)match[i] = -1; //ペアなしにしておく
for(int node_id = 0; node_id < V; node_id++){
if(match[node_id] < 0){ //node_idにペアがいない場合
for(int i = 0; i < V; i++)used[i] = false;
if(dfs(node_id)){ //増加パスが存在する場合
ret++;
}
}
}
return ret;
}
int main(){
int N;
scanf("%d",&N);
for(int i = 0; i < N; i++){
scanf("%d %d",&info[i].W,&info[i].H);
}
for(int from = 0; from < N; from++){
for(int to = 0; to < N; to++){
if((info[from].W < info[to].W && info[from].H < info[to].H) ||
(info[from].H < info[to].W && info[from].W < info[to].H)){
add_edge(from,N+to);
}
}
}
V = 2*N;
printf("%d\n",N-bipartie_matching());
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
Konrad is a Human Relations consultant working for VoltModder, a large electrical equipment producer. Today, he has been tasked with evaluating the level of happiness in the company.
There are n people working for VoltModder, numbered from 1 to n. Each employee earns a different amount of money in the company — initially, the i-th person earns i rubles per day.
On each of q following days, the salaries will be revised. At the end of the i-th day, employee v_i will start earning n+i rubles per day and will become the best-paid person in the company. The employee will keep his new salary until it gets revised again.
Some pairs of people don't like each other. This creates a great psychological danger in the company. Formally, if two people a and b dislike each other and a earns more money than b, employee a will brag about this to b. A dangerous triple is a triple of three employees a, b and c, such that a brags to b, who in turn brags to c. If a dislikes b, then b dislikes a.
At the beginning of each day, Konrad needs to evaluate the number of dangerous triples in the company. Can you help him do it?
Input
The first line contains two integers n and m (1 ≤ n ≤ 100 000, 0 ≤ m ≤ 100 000) — the number of employees in the company and the number of pairs of people who don't like each other. Each of the following m lines contains two integers a_i, b_i (1 ≤ a_i, b_i ≤ n, a_i ≠ b_i) denoting that employees a_i and b_i hate each other (that is, a_i dislikes b_i and b_i dislikes a_i). Each such relationship will be mentioned exactly once.
The next line contains an integer q (0 ≤ q ≤ 100 000) — the number of salary revisions. The i-th of the following q lines contains a single integer v_i (1 ≤ v_i ≤ n) denoting that at the end of the i-th day, employee v_i will earn the most.
Output
Output q + 1 integers. The i-th of them should contain the number of dangerous triples in the company at the beginning of the i-th day.
Examples
Input
4 5
1 2
2 4
1 3
3 4
2 3
2
2
3
Output
4
3
2
Input
3 3
1 2
2 3
1 3
5
1
2
2
1
3
Output
1
1
1
1
1
1
Note
Consider the first sample test. The i-th row in the following image shows the structure of the company at the beginning of the i-th day. A directed edge from a to b denotes that employee a brags to employee b. The dangerous triples are marked by highlighted edges.
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 99;
int n, m, q, u, v, deg[N], degin[N];
long long ans;
vector<int> g[N];
void change(int u, int v) {
ans -= 1ll * int(g[u].size()) * (deg[u] - int(g[u].size()));
g[u].push_back(v);
ans += 1ll * int(g[u].size()) * (deg[u] - int(g[u].size()));
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
scanf("%d%d", &u, &v);
;
if (v < u) swap(u, v);
g[u].push_back(v);
deg[u]++;
deg[v]++;
}
for (int i = 1; i < n + 1; i++)
ans += 1ll * int(g[i].size()) * (deg[i] - int(g[i].size()));
cout << ans << '\n';
cin >> q;
for (int i = 0; i < q; i++) {
cin >> u;
ans -= 1ll * int(g[u].size()) * (deg[u] - int(g[u].size()));
for (int i = 0; i < int(g[u].size()); i++) change(g[u][i], u);
g[u].clear();
cout << ans << '\n';
}
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
Celebrating the new year, many people post videos of falling dominoes; Here's a list of them: https://www.youtube.com/results?search_query=New+Years+Dominos
User ainta, who lives in a 2D world, is going to post a video as well.
There are n dominoes on a 2D Cartesian plane. i-th domino (1 ≤ i ≤ n) can be represented as a line segment which is parallel to the y-axis and whose length is li. The lower point of the domino is on the x-axis. Let's denote the x-coordinate of the i-th domino as pi. Dominoes are placed one after another, so p1 < p2 < ... < pn - 1 < pn holds.
User ainta wants to take a video of falling dominoes. To make dominoes fall, he can push a single domino to the right. Then, the domino will fall down drawing a circle-shaped orbit until the line segment totally overlaps with the x-axis.
<image>
Also, if the s-th domino touches the t-th domino while falling down, the t-th domino will also fall down towards the right, following the same procedure above. Domino s touches domino t if and only if the segment representing s and t intersects.
<image>
See the picture above. If he pushes the leftmost domino to the right, it falls down, touching dominoes (A), (B) and (C). As a result, dominoes (A), (B), (C) will also fall towards the right. However, domino (D) won't be affected by pushing the leftmost domino, but eventually it will fall because it is touched by domino (C) for the first time.
<image>
The picture above is an example of falling dominoes. Each red circle denotes a touch of two dominoes.
User ainta has q plans of posting the video. j-th of them starts with pushing the xj-th domino, and lasts until the yj-th domino falls. But sometimes, it could be impossible to achieve such plan, so he has to lengthen some dominoes. It costs one dollar to increase the length of a single domino by 1. User ainta wants to know, for each plan, the minimum cost needed to achieve it. Plans are processed independently, i. e. if domino's length is increased in some plan, it doesn't affect its length in other plans. Set of dominos that will fall except xj-th domino and yj-th domino doesn't matter, but the initial push should be on domino xj.
Input
The first line contains an integer n (2 ≤ n ≤ 2 × 105)— the number of dominoes.
Next n lines describe the dominoes. The i-th line (1 ≤ i ≤ n) contains two space-separated integers pi, li (1 ≤ pi, li ≤ 109)— the x-coordinate and the length of the i-th domino. It is guaranteed that p1 < p2 < ... < pn - 1 < pn.
The next line contains an integer q (1 ≤ q ≤ 2 × 105) — the number of plans.
Next q lines describe the plans. The j-th line (1 ≤ j ≤ q) contains two space-separated integers xj, yj (1 ≤ xj < yj ≤ n). It means the j-th plan is, to push the xj-th domino, and shoot a video until the yj-th domino falls.
Output
For each plan, print a line containing the minimum cost needed to achieve it. If no cost is needed, print 0.
Examples
Input
6
1 5
3 3
4 4
9 2
10 1
12 1
4
1 2
2 4
2 5
2 6
Output
0
1
1
2
Note
Consider the example. The dominoes are set like the picture below.
<image>
Let's take a look at the 4th plan. To make the 6th domino fall by pushing the 2nd domino, the length of the 3rd domino (whose x-coordinate is 4) should be increased by 1, and the 5th domino (whose x-coordinate is 9) should be increased by 1 (other option is to increase 4th domino instead of 5th also by 1). Then, the dominoes will fall like in the picture below. Each cross denotes a touch between two dominoes.
<image> <image> <image> <image> <image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int n, top, sta[N], se[N][2];
int nxt[N][20], cost[N][20];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d%d", &se[i][0], &se[i][1]);
se[i][1] += se[i][0];
for (; top;) {
if (se[i][1] <= se[sta[top - 1]][1]) break;
nxt[sta[--top]][0] = i;
}
sta[top++] = i;
}
for (; top; nxt[sta[--top]][0] = n)
;
nxt[n][0] = n;
for (int i = 0; i <= n; i++) {
int j = nxt[i][0];
if (j == n || se[j][0] < se[i][1])
cost[i][0] = 0;
else
cost[i][0] = se[j][0] - se[i][1];
}
for (int t = 1; t < 20; t++)
for (int i = 0; i <= n; i++) {
int j = nxt[i][t - 1];
nxt[i][t] = nxt[j][t - 1];
cost[i][t] = cost[i][t - 1] + cost[j][t - 1];
}
int Q;
scanf("%d", &Q);
while (Q--) {
int x, y;
scanf("%d%d", &x, &y);
x--;
y--;
int ans = 0;
for (int t = 19; t >= 0; t--)
if (nxt[x][t] <= y) {
ans += cost[x][t];
x = nxt[x][t];
}
printf("%d\n", ans);
}
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
Alice and Bob are playing a game with n piles of stones. It is guaranteed that n is an even number. The i-th pile has a_i stones.
Alice and Bob will play a game alternating turns with Alice going first.
On a player's turn, they must choose exactly n/2 nonempty piles and independently remove a positive number of stones from each of the chosen piles. They can remove a different number of stones from the piles in a single turn. The first player unable to make a move loses (when there are less than n/2 nonempty piles).
Given the starting configuration, determine who will win the game.
Input
The first line contains one integer n (2 ≤ n ≤ 50) — the number of piles. It is guaranteed that n is an even number.
The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 50) — the number of stones in the piles.
Output
Print a single string "Alice" if Alice wins; otherwise, print "Bob" (without double quotes).
Examples
Input
2
8 8
Output
Bob
Input
4
3 1 4 1
Output
Alice
Note
In the first example, each player can only remove stones from one pile (2/2=1). Alice loses, since Bob can copy whatever Alice does on the other pile, so Alice will run out of moves first.
In the second example, Alice can remove 2 stones from the first pile and 3 stones from the third pile on her first move to guarantee a win.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int a[51];
int n;
int main() {
scanf("%d", &n);
set<int> s;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
sort(a, a + n);
int cnt = 0;
for (int i = 0; i < n; i++) {
if (a[i] == a[0]) cnt++;
}
if (cnt > n / 2)
cout << "Bob" << endl;
else {
cout << "Alice" << endl;
}
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
Dima came to the horse land. There are n horses living in the land. Each horse in the horse land has several enemies (enmity is a symmetric relationship). The horse land isn't very hostile, so the number of enemies of each horse is at most 3.
Right now the horse land is going through an election campaign. So the horses trusted Dima to split them into two parts. At that the horses want the following condition to hold: a horse shouldn't have more than one enemy in its party.
Help Dima split the horses into parties. Note that one of the parties can turn out to be empty.
Input
The first line contains two integers n, m <image> — the number of horses in the horse land and the number of enemy pairs.
Next m lines define the enemy pairs. The i-th line contains integers ai, bi (1 ≤ ai, bi ≤ n; ai ≠ bi), which mean that horse ai is the enemy of horse bi.
Consider the horses indexed in some way from 1 to n. It is guaranteed that each horse has at most three enemies. No pair of enemies occurs more than once in the input.
Output
Print a line, consisting of n characters: the i-th character of the line must equal "0", if the horse number i needs to go to the first party, otherwise this character should equal "1".
If there isn't a way to divide the horses as required, print -1.
Examples
Input
3 3
1 2
3 2
3 1
Output
100
Input
2 1
2 1
Output
00
Input
10 6
1 2
1 3
1 4
2 3
2 4
3 4
Output
0110000000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300005;
int m, n, xc, yc, rc, fc, cs, t1;
vector<int> f[maxn];
int biao[maxn], u[maxn];
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d %d", &xc, &yc);
f[xc].push_back(yc);
f[yc].push_back(xc);
}
memset(biao, 0, sizeof(biao));
for (int i = 1; i <= n; i++)
if (biao[i] == 0) {
rc = 1;
fc = 1;
u[rc] = i;
biao[i] = 1;
while (rc <= fc) {
for (int j = 0; j < f[u[rc]].size(); j++) {
cs = f[u[rc]][j];
if (biao[cs] == 0) {
biao[cs] = 3 - biao[u[rc]];
++fc;
u[fc] = cs;
}
}
++rc;
}
}
for (int tt = 1; tt <= 10; tt++) {
for (int i = 1; i <= n; i++)
if (f[i].size() == 3) {
t1 = 0;
if (biao[i] == biao[f[i][0]]) ++t1;
if (biao[i] == biao[f[i][1]]) ++t1;
if (biao[i] == biao[f[i][2]]) ++t1;
if (t1 > 1) biao[i] = 3 - biao[i];
}
}
for (int i = 1; i <= n; i++) printf("%d", biao[i] - 1);
cout << endl;
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
One day, ZS the Coder wrote down an array of integers a with elements a1, a2, ..., an.
A subarray of the array a is a sequence al, al + 1, ..., ar for some integers (l, r) such that 1 ≤ l ≤ r ≤ n. ZS the Coder thinks that a subarray of a is beautiful if the bitwise xor of all the elements in the subarray is at least k.
Help ZS the Coder find the number of beautiful subarrays of a!
Input
The first line contains two integers n and k (1 ≤ n ≤ 106, 1 ≤ k ≤ 109) — the number of elements in the array a and the value of the parameter k.
The second line contains n integers ai (0 ≤ ai ≤ 109) — the elements of the array a.
Output
Print the only integer c — the number of beautiful subarrays of the array a.
Examples
Input
3 1
1 2 3
Output
5
Input
3 2
1 2 3
Output
3
Input
3 3
1 2 3
Output
2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const int N = 1e4 + 5;
struct Node {
int cnt;
Node* nxt[2];
Node() {
cnt = 0;
memset(nxt, 0, sizeof nxt);
}
};
Node* rt;
int n, k;
void add(int x) {
Node* cur = rt;
for (int i = 30; i >= 0; i--) {
bool b = ((1 << i) & x);
if (!cur->nxt[b]) cur->nxt[b] = new Node();
cur = cur->nxt[b];
cur->cnt++;
}
}
int query(int x) {
Node* cur = rt;
int cnt = 0;
for (int i = 30; i >= 0; i--) {
bool bx = (1 << i) & x, bk = (1 << i) & k;
if (!bk) {
if (cur->nxt[!bx]) {
cnt += cur->nxt[!bx]->cnt;
}
if (!cur->nxt[bx]) return cnt;
cur = cur->nxt[bx];
} else {
if (!cur->nxt[!bx]) return cnt;
cur = cur->nxt[!bx];
}
}
return cnt;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
rt = new Node();
cin >> n >> k;
int arr[n];
long long ans = 0;
add(0);
k--;
for (int i = 0; i < n; i++) {
cin >> arr[i];
if (i) arr[i] ^= arr[i - 1];
ans += query(arr[i]);
add(arr[i]);
}
cout << ans;
return 0;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
You are given an integer n.
You can perform any of the following operations with this number an arbitrary (possibly, zero) number of times:
1. Replace n with n/2 if n is divisible by 2;
2. Replace n with 2n/3 if n is divisible by 3;
3. Replace n with 4n/5 if n is divisible by 5.
For example, you can replace 30 with 15 using the first operation, with 20 using the second operation or with 24 using the third operation.
Your task is to find the minimum number of moves required to obtain 1 from n or say that it is impossible to do it.
You have to answer q independent queries.
Input
The first line of the input contains one integer q (1 ≤ q ≤ 1000) — the number of queries.
The next q lines contain the queries. For each query you are given the integer number n (1 ≤ n ≤ 10^{18}).
Output
Print the answer for each query on a new line. If it is impossible to obtain 1 from n, print -1. Otherwise, print the minimum number of moves required to do it.
Example
Input
7
1
10
25
30
14
27
1000000000000000000
Output
0
4
6
6
-1
6
72
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int q;
long long n;
int main() {
cin >> q;
for (; q >= 1; q--) {
cin >> n;
int a = 0, b = 0, c = 0;
while (n % 2 == 0) {
a++;
n /= 2;
}
while (n % 3 == 0) {
b++;
n /= 3;
}
while (n % 5 == 0) {
c++;
n /= 5;
}
if (n != 1) {
cout << "-1" << endl;
} else {
cout << a + 2 * b + 3 * c << endl;
}
}
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
Given two non-negative decimal integers $a$ and $b$, calculate their AND (logical conjunction), OR (logical disjunction) and XOR (exclusive disjunction) and print them in binary representation of 32 bits.
Constraints
* $0 \leq a, b \leq 2^{32} - 1$
Input
The input is given in the following format.
$a \; b$
Output
Print results of AND, OR and XOR in a line respectively.
Example
Input
8 10
Output
00000000000000000000000000001000
00000000000000000000000000001010
00000000000000000000000000000010
### Response
```cpp
#include <stdio.h>
void print_32bits(unsigned x) //32ビットで表示する
{
for (int i = 31; i >= 0; i--)
{
unsigned s = (x >> i);
if (s & 1U)
{
putchar('1');
}
else
{
putchar('0');
}
}
printf("\n");
}
int main(void)
{
unsigned a, b;
scanf("%u %u", &a, &b);
print_32bits(a & b);
print_32bits(a | b);
print_32bits(a ^ b);
return 0;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
There are N squares numbered 1 to N from left to right. Each square has a character written on it, and Square i has a letter s_i. Besides, there is initially one golem on each square.
Snuke cast Q spells to move the golems.
The i-th spell consisted of two characters t_i and d_i, where d_i is `L` or `R`. When Snuke cast this spell, for each square with the character t_i, all golems on that square moved to the square adjacent to the left if d_i is `L`, and moved to the square adjacent to the right if d_i is `R`.
However, when a golem tried to move left from Square 1 or move right from Square N, it disappeared.
Find the number of golems remaining after Snuke cast the Q spells.
Constraints
* 1 \leq N,Q \leq 2 \times 10^{5}
* |s| = N
* s_i and t_i are uppercase English letters.
* d_i is `L` or `R`.
Input
Input is given from Standard Input in the following format:
N Q
s
t_1 d_1
\vdots
t_{Q} d_Q
Output
Print the answer.
Examples
Input
3 4
ABC
A L
B L
B R
A R
Output
2
Input
8 3
AABCBDBA
A L
B R
A R
Output
5
Input
10 15
SNCZWRCEWB
B R
R R
E R
W R
Z L
S R
Q L
W L
B R
C L
A L
N L
E R
Z L
S L
Output
3
### Response
```cpp
#include<iostream>
#include<iomanip>
//#include<cstdio>
#include<vector>
#include<map>
#include<queue>
#include<algorithm>
#include<cmath>
#include<cassert>
using namespace std;
typedef long long ll;
const int Qmax = 2e5;
int N, Q;
string S;
char T[Qmax], D[Qmax];
int main(){
cin >> N >> Q;
cin >> S;
for(int i=0; i<Q; i++) cin >> T[i] >> D[i];
int l=0, r=N-1;
for(int i=Q-1; i>=0; i--){
if(S[l]==T[i]&&D[i]=='L') l++;
if(l>0&&S[l-1]==T[i]&&D[i]=='R') l--;
if(S[r]==T[i]&&D[i]=='R') r--;
if(r<N-1&&S[r+1]==T[i]&&D[i]=='L') r++;
}
// cout << r-l+1 << " " << l << " " << r << endl;
cout << r-l+1 << endl;
return 0;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
Vitya is studying in the third grade. During the last math lesson all the pupils wrote on arithmetic quiz. Vitya is a clever boy, so he managed to finish all the tasks pretty fast and Oksana Fillipovna gave him a new one, that is much harder.
Let's denote a flip operation of an integer as follows: number is considered in decimal notation and then reverted. If there are any leading zeroes afterwards, they are thrown away. For example, if we flip 123 the result is the integer 321, but flipping 130 we obtain 31, and by flipping 31 we come to 13.
Oksana Fillipovna picked some number a without leading zeroes, and flipped it to get number ar. Then she summed a and ar, and told Vitya the resulting value n. His goal is to find any valid a.
As Oksana Fillipovna picked some small integers as a and ar, Vitya managed to find the answer pretty fast and became interested in finding some general algorithm to deal with this problem. Now, he wants you to write the program that for given n finds any a without leading zeroes, such that a + ar = n or determine that such a doesn't exist.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 10100 000).
Output
If there is no such positive integer a without leading zeroes that a + ar = n then print 0. Otherwise, print any valid a. If there are many possible answers, you are allowed to pick any.
Examples
Input
4
Output
2
Input
11
Output
10
Input
5
Output
0
Input
33
Output
21
Note
In the first sample 4 = 2 + 2, a = 2 is the only possibility.
In the second sample 11 = 10 + 1, a = 10 — the only valid solution. Note, that a = 01 is incorrect, because a can't have leading zeroes.
It's easy to check that there is no suitable a in the third sample.
In the fourth sample 33 = 30 + 3 = 12 + 21, so there are three possibilities for a: a = 30, a = 12, a = 21. Any of these is considered to be correct answer.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100100;
int n;
string s;
int a[maxn];
int ans[maxn], done;
void check(int l, int dl, int r, int dr) {
while (1) {
if (l == r) {
if ((a[l] - dr) & 1) return;
ans[l] = (dl * 10 + a[l]) / 2;
done = true;
return;
} else if (l == r + 1) {
if (dr == dl) done = true;
return;
} else if (dl) {
ans[l] = 9;
ans[r] = (10 + a[r] - ans[l] - dr) % 10;
} else {
ans[l] = (r == n - 1);
ans[r] = (10 + a[r] - ans[l] - dr) % 10;
}
dr = (ans[r] + ans[l] + dr) / 10;
dl = 10 * dl + a[l] - (ans[r] + ans[l]);
if (dr and dr - 1) return;
if (dl and dl - 1) return;
l++, r--;
}
}
void show(int i) {
for (; i < n; i++) cout << ans[i];
cout << endl;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> s;
n = s.size();
for (int i = 0; i < n; i++) a[i] = s[i] - '0';
check(0, 0, n - 1, 0);
if (done) {
show(0);
return 0;
}
memset(ans, 0, sizeof ans);
if (s[0] == '1' and n > 1) check(1, 1, n - 1, 0);
for (int i = 0; i < n; i++)
if (ans[i] < 0 or ans[i] > 9) done = false;
if (done) {
show(1);
return 0;
}
cout << 0 << endl;
return 0;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
Broken crypto generator
JAG (Japanese Alumni Group) is a mysterious organization composed of many programmers, and in order to enter the building where the headquarters of this organization is located, it is necessary to solve the ciphertext generated by a certain machine every time. This ciphertext consists of the symbols'+','-','[',']' and the uppercase alphabet, and is represented by <Cipher> defined by the following BNF.
<Cipher> :: = <String> | <Cipher> <String>
<String> :: = <Letter> |'['<Cipher>']'
<Letter> :: ='+' <Letter> |'-' <Letter> |
'A' |'B' |'C' |'D' |'E' |'F' |'G' |'H' |'I' |'J' |'K' |'L' |'M '|
'N' |'O' |'P' |'Q' |'R' |'S' |'T' |'U' |'V' |'W' |'X' |'Y' |'Z '
Here, each symbol has the following meaning.
* + (Character): Represents the alphabet following that character (provided that the alphabet following'Z'is'A')
*-(Character): Represents the alphabet before that character (provided that the alphabet before'A'is'Z')
* [(Character string)]: Represents a character string that is horizontally inverted.
However, the machine that generates this ciphertext is currently out of order, and some letters of the alphabet in the ciphertext may be broken and unreadable. Unreadable characters are tentatively represented as'?'. As a result of the investigation, it was found that the method of filling the broken characters is such that the decrypted character string is the smallest in the dictionary order among the possible character strings after decoding. Your job is to decrypt this ciphertext correctly.
Input
The input consists of multiple datasets. Each dataset consists of one line containing a string in which some uppercase letters have been replaced with ‘?’ In the ciphertext defined by BNF above. You can assume that the length of each string is less than $ 80 $. You can also assume that the number of'?' In each dataset is greater than or equal to $ 0 $ and less than or equal to $ 3 $.
The end of the input is represented by a line containing only one character,'.'.
Output
For each data set, output the decrypted character string when the ciphertext is decrypted so that the decrypted character string is the smallest in the dictionary order.
Sample Input
A + A ++ A
Z-Z--Z + -Z
[ESREVER]
J ---? --- J
++++++++ A +++ Z ----------- A +++ Z
[[++-+-? [-++-? ++-+++ L]] [-+ ----- + -O]] ++++ --- + L
..
Output for Sample Input
ABC
ZYXZ
REVERSE
JAG
ICPC
JAPAN
Example
Input
A+A++A
Z-Z--Z+-Z
[ESREVER]
J---?---J
++++++++A+++Z-----------A+++Z
[[++-+--?[--++-?++-+++L]][-+-----+-O]]++++---+L
.
Output
ABC
ZYXZ
REVERSE
JAG
ICPC
JAPAN
### Response
```cpp
#define NDEBUG
#include <algorithm>
#include <cassert>
#include <cstdlib>
#include <iostream>
using namespace std;
#define ALL(x) begin(x), end(x)
char Letter(string::const_iterator&);
string String(string::const_iterator&);
string Cipher(string::const_iterator&);
char Letter(string::const_iterator &it) {
if(*it == '+') {
++it;
char res = Letter(it);
if(res != '?' && ++res > 'Z') res = 'A';
return res;
}
else if(*it == '-') {
++it;
char res = Letter(it);
if(res != '?' && --res < 'A') res = 'Z';
return res;
}
else if(isupper(*it) || *it == '?') {
const char res = *it;
++it;
return res;
}
assert(false);
}
string String(string::const_iterator &it) {
if(*it == '[') {
++it;
string res = Cipher(it);
assert(*it == ']');
++it;
reverse(ALL(res));
return res;
}
return string(1, Letter(it));
}
string Cipher(string::const_iterator &it) {
string res = "";
while(*it != '\0' && *it != ']') {
res += String(it);
}
return res;
}
string parse(const string &text) {
auto it = text.cbegin();
string res = Cipher(it);
assert(it == text.cend());
for(auto &e : res) {
if(e == '?') e = 'A';
}
return res;
}
int main(){
cin.tie(nullptr);
ios::sync_with_stdio(false);
for(string text; cin >> text && text != ".";) {
cout << parse(text) << endl;
}
return EXIT_SUCCESS;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Fox Ciel is playing a card game with her friend Fox Jiro. There are n piles of cards on the table. And there is a positive integer on each card.
The players take turns and Ciel takes the first turn. In Ciel's turn she takes a card from the top of any non-empty pile, and in Jiro's turn he takes a card from the bottom of any non-empty pile. Each player wants to maximize the total sum of the cards he took. The game ends when all piles become empty.
Suppose Ciel and Jiro play optimally, what is the score of the game?
Input
The first line contain an integer n (1 ≤ n ≤ 100). Each of the next n lines contains a description of the pile: the first integer in the line is si (1 ≤ si ≤ 100) — the number of cards in the i-th pile; then follow si positive integers c1, c2, ..., ck, ..., csi (1 ≤ ck ≤ 1000) — the sequence of the numbers on the cards listed from top of the current pile to bottom of the pile.
Output
Print two integers: the sum of Ciel's cards and the sum of Jiro's cards if they play optimally.
Examples
Input
2
1 100
2 1 10
Output
101 10
Input
1
9 2 8 6 5 9 4 7 1 3
Output
30 15
Input
3
3 1 3 2
3 5 4 6
2 8 7
Output
18 18
Input
3
3 1000 1000 1000
6 1000 1000 1000 1000 1000 1000
5 1000 1000 1000 1000 1000
Output
7000 7000
Note
In the first example, Ciel will take the cards with number 100 and 1, Jiro will take the card with number 10.
In the second example, Ciel will take cards with numbers 2, 8, 6, 5, 9 and Jiro will take cards with numbers 4, 7, 1, 3.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, a = 0, b = 0, x;
vector<long long> v;
scanf("%lld", &n);
for (int i = 0; i < n; i++) {
scanf("%lld", &m);
for (int j = 0; j < m / 2; j++) {
scanf("%lld", &x);
a += x;
}
if (m % 2 == 1) {
scanf("%lld", &x);
v.push_back(x);
}
for (int j = 0; j < m / 2; j++) {
scanf("%lld", &x);
b += x;
}
}
sort(v.begin(), v.end());
for (int i = 0; i < v.size(); i++) {
if (i % 2 == 0)
a += v[v.size() - i - 1];
else
b += v[v.size() - i - 1];
}
cout << a << " " << b << endl;
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
The finalists of the "Russian Code Cup" competition in 2214 will be the participants who win in one of the elimination rounds.
The elimination rounds are divided into main and additional. Each of the main elimination rounds consists of c problems, the winners of the round are the first n people in the rating list. Each of the additional elimination rounds consists of d problems. The winner of the additional round is one person. Besides, k winners of the past finals are invited to the finals without elimination.
As a result of all elimination rounds at least n·m people should go to the finals. You need to organize elimination rounds in such a way, that at least n·m people go to the finals, and the total amount of used problems in all rounds is as small as possible.
Input
The first line contains two integers c and d (1 ≤ c, d ≤ 100) — the number of problems in the main and additional rounds, correspondingly. The second line contains two integers n and m (1 ≤ n, m ≤ 100). Finally, the third line contains an integer k (1 ≤ k ≤ 100) — the number of the pre-chosen winners.
Output
In the first line, print a single integer — the minimum number of problems the jury needs to prepare.
Examples
Input
1 10
7 2
1
Output
2
Input
2 2
2 1
2
Output
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int c, d;
int n, m;
int k;
cin >> c >> d >> n >> m;
cin >> k;
int sum = n * m - k;
int ans = 0;
if (sum <= 0) {
cout << 0 << endl;
return 0;
}
if (n * 1.0 / c > 1.0 / d) {
ans += (sum / n) * c;
sum %= n;
if (sum == 0) {
cout << ans << endl;
return 0;
} else {
ans += min(c, d * sum);
cout << ans << endl;
}
} else {
cout << sum * d << endl;
}
return 0;
}
``` |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.