text
stringlengths 424
69.5k
|
|---|
### Prompt
Develop a solution in Cpp to the problem described below:
Anton has the integer x. He is interested what positive integer, which doesn't exceed x, has the maximum sum of digits.
Your task is to help Anton and to find the integer that interests him. If there are several such integers, determine the biggest of them.
Input
The first line contains the positive integer x (1 β€ x β€ 1018) β the integer which Anton has.
Output
Print the positive integer which doesn't exceed x and has the maximum sum of digits. If there are several such integers, print the biggest of them. Printed integer must not contain leading zeros.
Examples
Input
100
Output
99
Input
48
Output
48
Input
521
Output
499
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long int T = 1, inf = 10000000000;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
while (T--) {
long long int n, sz, ans = 0, blag = 0, u, mn, ev = 0, mx, mini, i, v, q, p,
j, k, w, h, l, m, x, y, od = 0, total = 0, cc = 0,
pp = 0, flag = 0, klag = 0, sum = 0;
string s, s1 = "YES", s2 = "NO";
bool ok = 0;
n = 11;
cin >> s;
if (stoll(s, nullptr, 10) <= 9) {
cout << s;
break;
}
sz = s.size();
string s3(sz - 1, '9');
s3 = '0' + s3;
for (i = 1; i < 10; i++) {
s3[0]++;
if (s3 > s) {
for (j = sz - 1; j > 0; j--) {
s3[j]--;
if (s3 <= s) {
flag = 1;
break;
} else {
s3[j]++;
}
}
if (flag == 0) {
s3[0]--;
}
break;
}
}
if (s3[0] == '0') {
s3.erase(0, 1);
}
cout << s3 << "\n";
}
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
A number of skyscrapers have been built in a line. The number of skyscrapers was chosen uniformly at random between 2 and 314! (314 factorial, a very large number). The height of each skyscraper was chosen randomly and independently, with height i having probability 2 - i for all positive integers i. The floors of a skyscraper with height i are numbered 0 through i - 1.
To speed up transit times, a number of zip lines were installed between skyscrapers. Specifically, there is a zip line connecting the i-th floor of one skyscraper with the i-th floor of another skyscraper if and only if there are no skyscrapers between them that have an i-th floor.
Alice and Bob decide to count the number of skyscrapers.
Alice is thorough, and wants to know exactly how many skyscrapers there are. She begins at the leftmost skyscraper, with a counter at 1. She then moves to the right, one skyscraper at a time, adding 1 to her counter each time she moves. She continues until she reaches the rightmost skyscraper.
Bob is impatient, and wants to finish as fast as possible. He begins at the leftmost skyscraper, with a counter at 1. He moves from building to building using zip lines. At each stage Bob uses the highest available zip line to the right, but ignores floors with a height greater than h due to fear of heights. When Bob uses a zip line, he travels too fast to count how many skyscrapers he passed. Instead, he just adds 2i to his counter, where i is the number of the floor he's currently on. He continues until he reaches the rightmost skyscraper.
Consider the following example. There are 6 buildings, with heights 1, 4, 3, 4, 1, 2 from left to right, and h = 2. Alice begins with her counter at 1 and then adds 1 five times for a result of 6. Bob begins with his counter at 1, then he adds 1, 4, 4, and 2, in order, for a result of 12. Note that Bob ignores the highest zip line because of his fear of heights (h = 2).
<image>
Bob's counter is at the top of the image, and Alice's counter at the bottom. All zip lines are shown. Bob's path is shown by the green dashed line and Alice's by the pink dashed line. The floors of the skyscrapers are numbered, and the zip lines Bob uses are marked with the amount he adds to his counter.
When Alice and Bob reach the right-most skyscraper, they compare counters. You will be given either the value of Alice's counter or the value of Bob's counter, and must compute the expected value of the other's counter.
Input
The first line of input will be a name, either string "Alice" or "Bob". The second line of input contains two integers n and h (2 β€ n β€ 30000, 0 β€ h β€ 30). If the name is "Alice", then n represents the value of Alice's counter when she reaches the rightmost skyscraper, otherwise n represents the value of Bob's counter when he reaches the rightmost skyscraper; h represents the highest floor number Bob is willing to use.
Output
Output a single real value giving the expected value of the Alice's counter if you were given Bob's counter, or Bob's counter if you were given Alice's counter.
You answer will be considered correct if its absolute or relative error doesn't exceed 10 - 9.
Examples
Input
Alice
3 1
Output
3.500000000
Input
Bob
2 30
Output
2
Input
Alice
2572 10
Output
3439.031415943
Note
In the first example, Bob's counter has a 62.5% chance of being 3, a 25% chance of being 4, and a 12.5% chance of being 5.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int RLEN = 1 << 20 | 1;
inline char gc() {
static char ibuf[RLEN], *ib, *ob;
(ob == ib) && (ob = (ib = ibuf) + fread(ibuf, 1, RLEN, stdin));
return (ob == ib) ? EOF : *ib++;
}
inline int read() {
char ch = getchar();
int res = 0, f = 1;
while (!isdigit(ch)) f ^= ch == '-', ch = getchar();
while (isdigit(ch)) res = (res + (res << 2) << 1) + (ch ^ 48), ch = getchar();
return f ? res : -res;
}
template <class tp>
inline void chemx(tp &a, tp b) {
a < b ? a = b : 0;
}
template <class tp>
inline void chemn(tp &a, tp b) {
a > b ? a = b : 0;
}
int n, h;
double pw[73];
char s[10];
inline double ksm(double a, int b) {
double res = 1;
for (; b; b >>= 1, a = a * a)
if (b & 1) res = res * a;
return res;
}
int main() {
scanf("%s", s + 1);
n = read(), h = read();
if (s[1] == 'A') {
pw[0] = 1;
for (int i = 1; i <= 2 * h; i++) pw[i] = pw[i - 1] * 0.5;
double res = n;
for (int i = 1; i <= h; i++)
for (int j = 1; j <= n; j++)
res += 1.0 * (n - j) * ksm(1 - pw[i], j - 1) * pw[i * 2] *
((1 << i) - 1.0 * (1 << (i - 1)) * 1.0 *
(1 + 1.0 * (j - 1) / ((1 << i) - 1)));
printf("%.10f", res);
} else
cout << n << '\n';
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
Squirrel Liss lived in a forest peacefully, but unexpected trouble happens. Stones fall from a mountain. Initially Squirrel Liss occupies an interval [0, 1]. Next, n stones will fall and Liss will escape from the stones. The stones are numbered from 1 to n in order.
The stones always fall to the center of Liss's interval. When Liss occupies the interval [k - d, k + d] and a stone falls to k, she will escape to the left or to the right. If she escapes to the left, her new interval will be [k - d, k]. If she escapes to the right, her new interval will be [k, k + d].
You are given a string s of length n. If the i-th character of s is "l" or "r", when the i-th stone falls Liss will escape to the left or to the right, respectively. Find the sequence of stones' numbers from left to right after all the n stones falls.
Input
The input consists of only one line. The only line contains the string s (1 β€ |s| β€ 106). Each character in s will be either "l" or "r".
Output
Output n lines β on the i-th line you should print the i-th stone's number from the left.
Examples
Input
llrlr
Output
3
5
4
2
1
Input
rrlll
Output
1
2
5
4
3
Input
lrlrr
Output
2
4
5
3
1
Note
In the first example, the positions of stones 1, 2, 3, 4, 5 will be <image>, respectively. So you should print the sequence: 3, 5, 4, 2, 1.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
char s[1000005];
int aim[1000005];
int l;
int main() {
cin >> s;
l = strlen(s);
int a = 0;
int b = l - 1;
for (int i = 0; i < l; i++) {
if (s[i] == 'l') {
aim[b] = i + 1;
b--;
} else {
aim[a] = i + 1;
a++;
}
}
for (int i = 0; i < l; i++) {
cout << aim[i] << endl;
}
return 0;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
Calendars in widespread use today include the Gregorian calendar, which is the de facto international standard, and is used almost everywhere in the world for civil purposes. The Gregorian reform modified the Julian calendar's scheme of leap years as follows:
Every year that is exactly divisible by four is a leap year, except for years that are exactly divisible by 100; the centurial years that are exactly divisible by 400 are still leap years. For example, the year 1900 is not a leap year; the year 2000 is a leap year.
<image>
In this problem, you have been given two dates and your task is to calculate how many days are between them. Note, that leap years have unusual number of days in February.
Look at the sample to understand what borders are included in the aswer.
Input
The first two lines contain two dates, each date is in the format yyyy:mm:dd (1900 β€ yyyy β€ 2038 and yyyy:mm:dd is a legal date).
Output
Print a single integer β the answer to the problem.
Examples
Input
1900:01:01
2038:12:31
Output
50768
Input
1996:03:09
1991:11:12
Output
1579
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct KK {
int y, m, d;
} a1, a2;
const int mon[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int main() {
int i;
while (scanf(" %d:%d:%d", &a1.y, &a1.m, &a1.d) == 3) {
scanf(" %d:%d:%d", &a2.y, &a2.m, &a2.d);
if (a1.y > a2.y) {
KK t = a1;
a1 = a2;
a2 = t;
}
int n = 365 * (a2.y - a1.y + 1);
for (i = a1.y; i <= a2.y; i++)
if ((!(i % 4) && (i % 100)) || !(i % 400)) n++;
for (i = 1; i < a1.m; i++) n -= mon[i];
if (((!(a1.y % 4) && (a1.y % 100)) || !(a1.y % 400)) && (a1.m > 2)) n--;
n -= a1.d;
n -= (mon[a2.m] - a2.d);
if (((!(a2.y % 4) && (a2.y % 100)) || !(a2.y % 400)) && (a2.m <= 2)) n--;
for (i = a2.m + 1; i < 13; i++) n -= mon[i];
cout << abs(n) << endl;
}
return 0;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
We have a grid with A horizontal rows and B vertical columns, with the squares painted white. On this grid, we will repeatedly apply the following operation:
* Assume that the grid currently has a horizontal rows and b vertical columns. Choose "vertical" or "horizontal".
* If we choose "vertical", insert one row at the top of the grid, resulting in an (a+1) \times b grid.
* If we choose "horizontal", insert one column at the right end of the grid, resulting in an a \times (b+1) grid.
* Then, paint one of the added squares black, and the other squares white.
Assume the grid eventually has C horizontal rows and D vertical columns. Find the number of ways in which the squares can be painted in the end, modulo 998244353.
Constraints
* 1 \leq A \leq C \leq 3000
* 1 \leq B \leq D \leq 3000
* A, B, C, and D are integers.
Input
Input is given from Standard Input in the following format:
A B C D
Output
Print the number of ways in which the squares can be painted in the end, modulo 998244353.
Examples
Input
1 1 2 2
Output
3
Input
2 1 3 4
Output
65
Input
31 41 59 265
Output
387222020
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int mod=998244353;
int read() {
int x=0, f=1; char ch=' ';
while(!isdigit(ch)) {ch=getchar(); if(ch=='-') f=-1;}
while(isdigit(ch)) x=(x<<3)+(x<<1)+(ch^48), ch=getchar();
return x*f;
}
ll f[3005][3005];
int main() {
int a, b, c, d;
cin>>a>>b>>c>>d;
f[a][b]=1;
for(int i=a;i<=c;i++) {
for(int j=b;j<=d;j++) {
if(i>a) f[i][j]+=f[i-1][j]*j;
if(j>b) f[i][j]+=f[i][j-1]*i;
if(i>a&&j>b) f[i][j]-=(ll)(i-1)*(j-1)*f[i-1][j-1];
f[i][j]%=mod;
}
}
cout<<(f[c][d]%mod+mod)%mod;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Little Vasya has received a young builderβs kit. The kit consists of several wooden bars, the lengths of all of them are known. The bars can be put one on the top of the other if their lengths are the same.
Vasya wants to construct the minimal number of towers from the bars. Help Vasya to use the bars in the best way possible.
Input
The first line contains an integer N (1 β€ N β€ 1000) β the number of bars at Vasyaβs disposal. The second line contains N space-separated integers li β the lengths of the bars. All the lengths are natural numbers not exceeding 1000.
Output
In one line output two numbers β the height of the largest tower and their total number. Remember that Vasya should use all the bars.
Examples
Input
3
1 2 3
Output
1 3
Input
4
6 5 6 7
Output
2 3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
map<int, int> a;
set<int> w;
int c, x, ma = 1, q = 0, s = 0;
cin >> c;
for (int i = 0; i < c; i++) {
cin >> x;
a[x]++;
ma = max(ma, a[x]);
w.insert(x);
}
cout << ma << " " << w.size();
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
Momiji has got a rooted tree, consisting of n nodes. The tree nodes are numbered by integers from 1 to n. The root has number 1. Momiji decided to play a game on this tree.
The game consists of several steps. On each step, Momiji chooses one of the remaining tree nodes (let's denote it by v) and removes all the subtree nodes with the root in node v from the tree. Node v gets deleted as well. The game finishes when the tree has no nodes left. In other words, the game finishes after the step that chooses the node number 1.
Each time Momiji chooses a new node uniformly among all the remaining nodes. Your task is to find the expectation of the number of steps in the described game.
Input
The first line contains integer n (1 β€ n β€ 105) β the number of nodes in the tree. The next n - 1 lines contain the tree edges. The i-th line contains integers ai, bi (1 β€ ai, bi β€ n; ai β bi) β the numbers of the nodes that are connected by the i-th edge.
It is guaranteed that the given graph is a tree.
Output
Print a single real number β the expectation of the number of steps in the described game.
The answer will be considered correct if the absolute or relative error doesn't exceed 10 - 6.
Examples
Input
2
1 2
Output
1.50000000000000000000
Input
3
1 2
1 3
Output
2.00000000000000000000
Note
In the first sample, there are two cases. One is directly remove the root and another is remove the root after one step. Thus the expected steps are:
1 Γ (1 / 2) + 2 Γ (1 / 2) = 1.5
In the second sample, things get more complex. There are two cases that reduce to the first sample, and one case cleaned at once. Thus the expected steps are:
1 Γ (1 / 3) + (1 + 1.5) Γ (2 / 3) = (1 / 3) + (5 / 3) = 2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, tot = 0;
int v[200005], nxt[200005], h[100005], dep[100005];
void addedge(int x, int y) {
v[++tot] = y;
nxt[tot] = h[x];
h[x] = tot;
v[++tot] = x;
nxt[tot] = h[y];
h[y] = tot;
}
void dfs(int u, int fa) {
for (int p = h[u]; p; p = nxt[p]) {
if (v[p] == fa) continue;
dep[v[p]] = dep[u] + 1;
dfs(v[p], u);
}
}
int main() {
cin >> n;
int x, y;
for (int i = 1; i <= n - 1; i++) {
cin >> x >> y;
addedge(x, y);
}
dep[1] = 1;
dfs(1, -1);
double ans = 0;
for (int i = 1; i <= n; i++) ans += 1.0 / dep[i];
printf("%.10lf\n", ans);
return 0;
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
There are n people and k keys on a straight line. Every person wants to get to the office which is located on the line as well. To do that, he needs to reach some point with a key, take the key and then go to the office. Once a key is taken by somebody, it couldn't be taken by anybody else.
You are to determine the minimum time needed for all n people to get to the office with keys. Assume that people move a unit distance per 1 second. If two people reach a key at the same time, only one of them can take the key. A person can pass through a point with a key without taking it.
Input
The first line contains three integers n, k and p (1 β€ n β€ 1 000, n β€ k β€ 2 000, 1 β€ p β€ 109) β the number of people, the number of keys and the office location.
The second line contains n distinct integers a1, a2, ..., an (1 β€ ai β€ 109) β positions in which people are located initially. The positions are given in arbitrary order.
The third line contains k distinct integers b1, b2, ..., bk (1 β€ bj β€ 109) β positions of the keys. The positions are given in arbitrary order.
Note that there can't be more than one person or more than one key in the same point. A person and a key can be located in the same point.
Output
Print the minimum time (in seconds) needed for all n to reach the office with keys.
Examples
Input
2 4 50
20 100
60 10 40 80
Output
50
Input
1 2 10
11
15 7
Output
7
Note
In the first example the person located at point 20 should take the key located at point 40 and go with it to the office located at point 50. He spends 30 seconds. The person located at point 100 can take the key located at point 80 and go to the office with it. He spends 50 seconds. Thus, after 50 seconds everybody is in office with keys.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
namespace FAST_IO {
inline char Getchar() {
static char buf[500000], *l = buf, *r = buf;
if (l == r) r = (l = buf) + fread(buf, 1, 500000, stdin);
return (l == r) ? EOF : *l++;
}
char obuf[500000], *ooh = obuf;
inline void Putchar(char c) {
if (ooh == obuf + 500000) fwrite(obuf, 1, 500000, stdout), ooh = obuf;
*ooh++ = c;
}
inline long long rd() {
long long x = 0;
int ch = Getchar();
bool f = 1;
while (!isdigit(ch) && (ch != '-') && (ch != EOF)) ch = Getchar();
if (ch == '-') {
f = 0;
ch = Getchar();
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + ch - '0';
ch = Getchar();
}
return f ? x : -x;
}
void write(long long x) {
if (x >= 10)
write(x / 10), Putchar((char)(x % 10 + '0'));
else
Putchar((char)(x + '0'));
}
inline void wrt(long long x, int p) {
if (x < 0) Putchar('-'), x = -x;
write(x);
if (p) Putchar((char)p);
}
inline void flush() { fwrite(obuf, 1, ooh - obuf, stdout); }
} // namespace FAST_IO
using namespace FAST_IO;
int n, k, p;
long long a[1005], b[2005], dp[1005][2005], dp1[1005][2005];
inline long long Abs(long long x) { return x < 0 ? -x : x; }
int main() {
n = rd(), k = rd(), p = rd();
for (int i = int(1); i <= (int)(n); i++) a[i] = rd();
for (int i = int(1); i <= (int)(k); i++) b[i] = rd();
sort(b + 1, b + 1 + k);
sort(a + 1, a + n + 1);
for (int i = int(1); i <= (int)(n); i++)
for (int j = int(0); j <= (int)(k); j++)
dp[i][j] = dp1[i][j] = 1666666666666666;
for (int i = int(1); i <= (int)(n); i++)
for (int j = int(i); j <= (int)(k); j++)
dp[i][j] = max(dp1[i - 1][j - 1], Abs(a[i] - b[j]) + Abs(b[j] - p)),
dp1[i][j] = min(dp1[i][j - 1], dp[i][j]);
long long ans = 1666666666666666;
for (int i = int(1); i <= (int)(k); i++) ans = min(dp[n][i], ans);
wrt(ans, '\n');
flush();
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
Xenia the programmer has a tree consisting of n nodes. We will consider the tree nodes indexed from 1 to n. We will also consider the first node to be initially painted red, and the other nodes β to be painted blue.
The distance between two tree nodes v and u is the number of edges in the shortest path between v and u.
Xenia needs to learn how to quickly execute queries of two types:
1. paint a specified blue node in red;
2. calculate which red node is the closest to the given one and print the shortest distance to the closest red node.
Your task is to write a program which will execute the described queries.
Input
The first line contains two integers n and m (2 β€ n β€ 105, 1 β€ m β€ 105) β the number of nodes in the tree and the number of queries. Next n - 1 lines contain the tree edges, the i-th line contains a pair of integers ai, bi (1 β€ ai, bi β€ n, ai β bi) β an edge of the tree.
Next m lines contain queries. Each query is specified as a pair of integers ti, vi (1 β€ ti β€ 2, 1 β€ vi β€ n). If ti = 1, then as a reply to the query we need to paint a blue node vi in red. If ti = 2, then we should reply to the query by printing the shortest distance from some red node to node vi.
It is guaranteed that the given graph is a tree and that all queries are correct.
Output
For each second type query print the reply in a single line.
Examples
Input
5 4
1 2
2 3
2 4
4 5
2 1
2 5
1 2
2 5
Output
0
3
2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct LCA {
int p;
LCA() {}
} lca[100001][21];
int n, m;
set<int> AdjList[100001];
int p[100001];
int nChild[100001];
int d[100001];
int f[100001];
int cur_sz;
int lim;
void cal_dist(int u, int par) {
for (set<int>::iterator it = AdjList[u].begin(); it != AdjList[u].end();
it++) {
int v = *it;
if (v != par) {
lca[v][0].p = u;
d[v] = d[u] + 1;
cal_dist(v, u);
}
}
}
void cal_lca() {
for (int j = 1; j <= 20; j++)
for (int i = 1; i <= 100000; i++)
if (lca[i][j - 1].p != -1)
if (lca[lca[i][j - 1].p][j - 1].p != -1)
lca[i][j].p = lca[lca[i][j - 1].p][j - 1].p;
}
void cal_Child(int u, int par) {
cur_sz++;
nChild[u] = 1;
for (set<int>::iterator it = AdjList[u].begin(); it != AdjList[u].end();
it++) {
int v = *it;
if (v != par) {
cal_Child(v, u);
nChild[u] += nChild[v];
}
}
}
int find_Centroid(int u, int par) {
for (set<int>::iterator it = AdjList[u].begin(); it != AdjList[u].end();
it++) {
int v = *it;
if (v != par && nChild[v] > lim) return find_Centroid(v, u);
}
return u;
}
void Decomp(int u, int pre) {
cur_sz = 0;
cal_Child(u, -1);
lim = cur_sz / 2;
int Centroid = find_Centroid(u, -1);
p[Centroid] = pre;
for (set<int>::iterator it = AdjList[Centroid].begin();
it != AdjList[Centroid].end(); it++) {
int v = *it;
AdjList[v].erase(Centroid);
Decomp(v, Centroid);
}
}
int find_lca(int u, int v) {
if (d[u] > d[v]) swap(u, v);
for (int i = 20; i >= 0; i--)
if (lca[v][i].p != -1)
if (d[lca[v][i].p] >= d[u]) v = lca[v][i].p;
if (u == v) return u;
for (int i = 20; i >= 0; i--)
if (lca[v][i].p != -1 && lca[u][i].p != -1)
if (lca[v][i].p != lca[u][i].p) {
u = lca[u][i].p;
v = lca[v][i].p;
}
return lca[v][0].p;
}
int dist(int a, int b) { return (d[a] + d[b] - 2 * d[find_lca(a, b)]); }
void update(int u) {
int z = u;
while (u) {
f[u] = min(f[u], dist(z, u));
u = p[u];
}
}
int query(int u) {
int ans = 1e9;
int z = u;
while (u) {
ans = min(ans, f[u] + dist(z, u));
u = p[u];
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) f[i] = 1e9;
for (int i = 1; i <= n - 1; i++) {
int u, v;
cin >> u >> v;
AdjList[u].insert(v);
AdjList[v].insert(u);
}
d[1] = 0;
cal_dist(1, 0);
Decomp(1, 0);
for (int j = 1; j <= 20; j++)
for (int i = 1; i <= 100000; i++) lca[i][j].p = -1;
cal_lca();
update(1);
while (m--) {
int type, u;
cin >> type >> u;
if (type == 1)
update(u);
else
cout << query(u) << '\n';
}
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
A tree is a connected undirected graph consisting of n vertices and n - 1 edges. Vertices are numbered 1 through n.
Limak is a little polar bear and Radewoosh is his evil enemy. Limak once had a tree but Radewoosh stolen it. Bear is very sad now because he doesn't remember much about the tree β he can tell you only three values n, d and h:
* The tree had exactly n vertices.
* The tree had diameter d. In other words, d was the biggest distance between two vertices.
* Limak also remembers that he once rooted the tree in vertex 1 and after that its height was h. In other words, h was the biggest distance between vertex 1 and some other vertex.
The distance between two vertices of the tree is the number of edges on the simple path between them.
Help Limak to restore his tree. Check whether there exists a tree satisfying the given conditions. Find any such tree and print its edges in any order. It's also possible that Limak made a mistake and there is no suitable tree β in this case print "-1".
Input
The first line contains three integers n, d and h (2 β€ n β€ 100 000, 1 β€ h β€ d β€ n - 1) β the number of vertices, diameter, and height after rooting in vertex 1, respectively.
Output
If there is no tree matching what Limak remembers, print the only line with "-1" (without the quotes).
Otherwise, describe any tree matching Limak's description. Print n - 1 lines, each with two space-separated integers β indices of vertices connected by an edge. If there are many valid trees, print any of them. You can print edges in any order.
Examples
Input
5 3 2
Output
1 2
1 3
3 4
3 5
Input
8 5 2
Output
-1
Input
8 4 2
Output
4 8
5 7
2 3
8 1
2 1
5 6
1 5
Note
Below you can see trees printed to the output in the first sample and the third sample.
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<int> a[100005];
int main() {
int n, d, h;
cin >> n >> d >> h;
if (n == 2) {
cout << "1 2\n";
} else if (d > 2 * h || d == 1) {
cout << "-1";
} else {
for (int i = 1; i <= h; i++) {
a[i].push_back(i + 1);
}
if (d == h) {
for (int j = h + 2; j <= n; j++) a[2].push_back(j);
} else {
a[1].push_back(h + 2);
int remain = d - h - 1;
int node = h + 2;
while (remain > 0) {
a[node].push_back(node + 1);
node++;
remain--;
}
for (int j = d + 2; j <= n; j++) {
a[1].push_back(j);
}
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < a[i].size(); j++) cout << i << " " << a[i][j] << "\n";
}
}
return 0;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
There are N people standing in a row from west to east. Each person is facing east or west. The directions of the people is given as a string S of length N. The i-th person from the west is facing east if S_i = `E`, and west if S_i = `W`.
You will appoint one of the N people as the leader, then command the rest of them to face in the direction of the leader. Here, we do not care which direction the leader is facing.
The people in the row hate to change their directions, so you would like to select the leader so that the number of people who have to change their directions is minimized. Find the minimum number of people who have to change their directions.
Constraints
* 2 \leq N \leq 3 \times 10^5
* |S| = N
* S_i is `E` or `W`.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the minimum number of people who have to change their directions.
Examples
Input
5
WEEWW
Output
1
Input
12
WEWEWEEEWWWE
Output
4
Input
8
WWWWWEEE
Output
3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(){
int n;
string s;
cin>>n>>s;
int E[300009]={},W[300009]={};
for(int i=1;i<=n;i++){
W[i]=W[i-1];
if(s[i-1]=='W') W[i]++;
}
for(int i=n;i>=1;i--){
E[i]=E[i+1];
if(s[i-1]=='E') E[i]++;
}
int ans=n;
for(int i=1;i<=n;i++){
ans=min(ans,W[i-1]+E[i+1]);
}
cout<<ans;
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
One rainy gloomy evening when all modules hid in the nearby cafes to drink hot energetic cocktails, the Hexadecimal virus decided to fly over the Mainframe to look for a Great Idea. And she has found one!
Why not make her own Codeforces, with blackjack and other really cool stuff? Many people will surely be willing to visit this splendid shrine of high culture.
In Mainframe a standard pack of 52 cards is used to play blackjack. The pack contains cards of 13 values: 2, 3, 4, 5, 6, 7, 8, 9, 10, jacks, queens, kings and aces. Each value also exists in one of four suits: hearts, diamonds, clubs and spades. Also, each card earns some value in points assigned to it: cards with value from two to ten earn from 2 to 10 points, correspondingly. An ace can either earn 1 or 11, whatever the player wishes. The picture cards (king, queen and jack) earn 10 points. The number of points a card earns does not depend on the suit. The rules of the game are very simple. The player gets two cards, if the sum of points of those cards equals n, then the player wins, otherwise the player loses.
The player has already got the first card, it's the queen of spades. To evaluate chances for victory, you should determine how many ways there are to get the second card so that the sum of points exactly equals n.
Input
The only line contains n (1 β€ n β€ 25) β the required sum of points.
Output
Print the numbers of ways to get the second card in the required way if the first card is the queen of spades.
Examples
Input
12
Output
4
Input
20
Output
15
Input
10
Output
0
Note
In the first sample only four two's of different suits can earn the required sum of points.
In the second sample we can use all tens, jacks, queens and kings; overall it's 15 cards, as the queen of spades (as any other card) is only present once in the pack of cards and it's already in use.
In the third sample there is no card, that would add a zero to the current ten points.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int m = n - 10;
if (m <= 0) {
cout << 0;
return 0;
}
if (m <= 9) {
cout << 4;
return 0;
}
if (m == 10) {
cout << 15;
return 0;
}
if (m == 11) {
cout << 4;
return 0;
}
cout << 0;
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
Berland starts to seize the initiative on the war with Flatland. To drive the enemy from their native land, the berlanders need to know exactly how many more flatland soldiers are left in the enemy's reserve. Fortunately, the scouts captured an enemy in the morning, who had a secret encrypted message with the information the berlanders needed so much.
The captured enemy had an array of positive integers. Berland intelligence have long been aware of the flatland code: to convey the message, which contained a number m, the enemies use an array of integers a. The number of its subarrays, in which there are at least k equal numbers, equals m. The number k has long been known in the Berland army so General Touristov has once again asked Corporal Vasya to perform a simple task: to decipher the flatlanders' message.
Help Vasya, given an array of integers a and number k, find the number of subarrays of the array of numbers a, which has at least k equal numbers.
Subarray a[i... j] (1 β€ i β€ j β€ n) of array a = (a1, a2, ..., an) is an array, made from its consecutive elements, starting from the i-th one and ending with the j-th one: a[i... j] = (ai, ai + 1, ..., aj).
Input
The first line contains two space-separated integers n, k (1 β€ k β€ n β€ 4Β·105), showing how many numbers an array has and how many equal numbers the subarrays are required to have, correspondingly.
The second line contains n space-separated integers ai (1 β€ ai β€ 109) β elements of the array.
Output
Print the single number β the number of such subarrays of array a, that they have at least k equal integers.
Please do not use the %lld specifier to read or write 64-bit integers in Π‘++. In is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
4 2
1 2 1 2
Output
3
Input
5 3
1 2 1 1 3
Output
2
Input
3 1
1 1 1
Output
6
Note
In the first sample are three subarrays, containing at least two equal numbers: (1,2,1), (2,1,2) and (1,2,1,2).
In the second sample are two subarrays, containing three equal numbers: (1,2,1,1,3) and (1,2,1,1).
In the third sample any subarray contains at least one 1 number. Overall they are 6: (1), (1), (1), (1,1), (1,1) and (1,1,1).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<int> arr;
map<int, int> mass;
set<pair<int, int>> sost;
int main() {
int n, k;
scanf("%d%d", &n, &k);
long long ans = 0;
int pos = 0;
for (int i = 0; i < n; ++i) {
int x;
scanf("%d", &x);
arr.push_back(x);
sost.erase(make_pair(mass[arr[i]], arr[i]));
mass[x]++;
sost.insert(make_pair(mass[arr[i]], arr[i]));
while (sost.rbegin()->first >= k) {
ans += n - i;
sost.erase(make_pair(mass[arr[pos]], arr[pos]));
mass[arr[pos]]--;
sost.insert(make_pair(mass[arr[pos]], arr[pos]));
pos++;
}
}
cout << ans;
return 0;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
During the lesson small girl Alyona works with one famous spreadsheet computer program and learns how to edit tables.
Now she has a table filled with integers. The table consists of n rows and m columns. By ai, j we will denote the integer located at the i-th row and the j-th column. We say that the table is sorted in non-decreasing order in the column j if ai, j β€ ai + 1, j for all i from 1 to n - 1.
Teacher gave Alyona k tasks. For each of the tasks two integers l and r are given and Alyona has to answer the following question: if one keeps the rows from l to r inclusive and deletes all others, will the table be sorted in non-decreasing order in at least one column? Formally, does there exist such j that ai, j β€ ai + 1, j for all i from l to r - 1 inclusive.
Alyona is too small to deal with this task and asks you to help!
Input
The first line of the input contains two positive integers n and m (1 β€ nΒ·m β€ 100 000) β the number of rows and the number of columns in the table respectively. Note that your are given a constraint that bound the product of these two integers, i.e. the number of elements in the table.
Each of the following n lines contains m integers. The j-th integers in the i of these lines stands for ai, j (1 β€ ai, j β€ 109).
The next line of the input contains an integer k (1 β€ k β€ 100 000) β the number of task that teacher gave to Alyona.
The i-th of the next k lines contains two integers li and ri (1 β€ li β€ ri β€ n).
Output
Print "Yes" to the i-th line of the output if the table consisting of rows from li to ri inclusive is sorted in non-decreasing order in at least one column. Otherwise, print "No".
Example
Input
5 4
1 2 3 5
3 1 3 2
4 5 2 3
5 5 3 2
4 4 3 4
6
1 1
2 5
4 5
3 5
1 3
1 5
Output
Yes
No
Yes
Yes
Yes
No
Note
In the sample, the whole table is not sorted in any column. However, rows 1β3 are sorted in column 1, while rows 4β5 are sorted in column 3.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<int> a[100001];
int n, m, k, pos, ans[100001], ql[100001], qr[100001];
int out[100001];
int ed;
vector<pair<int, int>> qs[100001];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) a[i].resize(m + 1);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) scanf("%d", a[i].data() + j);
for (int j = 1; j <= m; ++j) {
int st = 1;
for (int i = 1; i < n; ++i) {
if (a[i][j] > a[i + 1][j]) {
if (st < i) out[st] = max(out[st], i + 1);
st = i + 1;
}
}
if (st < n) out[st] = max(out[st], n + 1);
}
scanf("%d", &k);
for (int i = 0; i < k; ++i)
scanf("%d%d", ql + i, qr + i), ans[i] = ql[i] == qr[i];
for (int i = 0; i < k; ++i)
if (ql[i] < qr[i]) {
qs[ql[i]].emplace_back(qr[i], i);
}
for (int i = 1; i <= n; ++i) {
ed = max(ed, out[i]);
for (auto&& x : qs[i]) ans[x.second] = x.first < ed;
}
for (int i = 0; i < k; ++i) puts(ans[i] ? "Yes" : "No");
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
You are given n arrays that can have different sizes. You also have a table with w columns and n rows. The i-th array is placed horizontally in the i-th row. You can slide each array within its row as long as it occupies several consecutive cells and lies completely inside the table.
You need to find the maximum sum of the integers in the j-th column for each j from 1 to w independently.
<image> Optimal placements for columns 1, 2 and 3 are shown on the pictures from left to right.
Note that you can exclude any array out of a column provided it remains in the window. In this case its value is considered to be zero.
Input
The first line contains two integers n (1 β€ n β€ 10^{6}) and w (1 β€ w β€ 10^{6}) β the number of arrays and the width of the table.
Each of the next n lines consists of an integer l_{i} (1 β€ l_{i} β€ w), the length of the i-th array, followed by l_{i} integers a_{i1}, a_{i2}, β¦, a_{il_i} (-10^{9} β€ a_{ij} β€ 10^{9}) β the elements of the array.
The total length of the arrays does no exceed 10^{6}.
Output
Print w integers, the i-th of them should be the maximum sum for column i.
Examples
Input
3 3
3 2 4 8
2 2 5
2 6 3
Output
10 15 16
Input
2 2
2 7 8
1 -8
Output
7 8
Note
Illustration for the first example is in the statement.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 5;
multiset<int> s[maxn];
int n, w;
vector<pair<int, int> > ql[maxn], qr[maxn];
long long ans[maxn];
int main() {
cin >> n >> w;
for (int i = 1; i <= n; i++) {
s[i].insert(-0x3f3f3f3f);
int l;
scanf("%d", &l);
for (int j = 1; j <= l; j++) {
int t;
scanf("%d", &t);
ql[j].push_back(make_pair(i, t));
qr[w - l + j + 1].push_back(make_pair(i, t));
}
if (l < w) {
ql[l + 1].push_back(make_pair(i, 0));
ql[1].push_back(make_pair(i, 0));
qr[w - l + 1].push_back(make_pair(i, 0));
}
}
multiset<int>::iterator it, it1;
long long sum = 0;
for (int i = 1; i <= w; i++) {
for (auto j : qr[i]) {
it = s[j.first].lower_bound(j.second);
it1 = it;
it1++;
if (it1 == s[j.first].end()) {
it1--;
it1--;
if (it1 == s[j.first].begin())
sum -= j.second;
else
sum += *it1 - j.second;
}
s[j.first].erase(it);
}
for (auto j : ql[i]) {
s[j.first].insert(j.second);
it = s[j.first].lower_bound(j.second);
it1 = it;
it1++;
if (it1 == s[j.first].end()) {
it1 = it;
it1--;
if (it1 == s[j.first].begin())
sum += j.second;
else
sum += j.second - *it1;
}
}
ans[i] = sum;
}
for (int i = 1; i <= w; i++) printf("%lld ", ans[i]);
return 0;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
Sometimes Mister B has free evenings when he doesn't know what to do. Fortunately, Mister B found a new game, where the player can play against aliens.
All characters in this game are lowercase English letters. There are two players: Mister B and his competitor.
Initially the players have a string s consisting of the first a English letters in alphabetical order (for example, if a = 5, then s equals to "abcde").
The players take turns appending letters to string s. Mister B moves first.
Mister B must append exactly b letters on each his move. He can arbitrary choose these letters. His opponent adds exactly a letters on each move.
Mister B quickly understood that his opponent was just a computer that used a simple algorithm. The computer on each turn considers the suffix of string s of length a and generates a string t of length a such that all letters in the string t are distinct and don't appear in the considered suffix. From multiple variants of t lexicographically minimal is chosen (if a = 4 and the suffix is "bfdd", the computer chooses string t equal to "aceg"). After that the chosen string t is appended to the end of s.
Mister B soon found the game boring and came up with the following question: what can be the minimum possible number of different letters in string s on the segment between positions l and r, inclusive. Letters of string s are numerated starting from 1.
Input
First and only line contains four space-separated integers: a, b, l and r (1 β€ a, b β€ 12, 1 β€ l β€ r β€ 109) β the numbers of letters each player appends and the bounds of the segment.
Output
Print one integer β the minimum possible number of different letters in the segment from position l to position r, inclusive, in string s.
Examples
Input
1 1 1 8
Output
2
Input
4 2 2 6
Output
3
Input
3 7 4 6
Output
1
Note
In the first sample test one of optimal strategies generate string s = "abababab...", that's why answer is 2.
In the second sample test string s = "abcdbcaefg..." can be obtained, chosen segment will look like "bcdbc", that's why answer is 3.
In the third sample test string s = "abczzzacad..." can be obtained, chosen, segment will look like "zzz", that's why answer is 1.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int a, b, l, r;
int main() {
cin >> a >> b >> l >> r;
l--;
r--;
int pl = l % (a + b);
int pr = r % (a + b);
int cl = l / (a + b);
int cr = r / (a + b);
if (b >= a) {
if (cr > cl + 1) {
printf("%d\n", a + 1);
} else if (cr == cl + 1) {
int le = max(1, a - pl);
int ri = min(a, pr + 1);
int ans = min(a, le + ri);
if (ri == a) ans++;
printf("%d\n", ans);
} else {
printf("%d\n", min(pr - pl + 1, max(1, a - pl)));
}
} else {
int minus = a - b;
if (cr > cl + 2) {
printf("%d\n", minus + a);
} else if (cr == cl + 2) {
printf("%d\n", a + max(1, min(minus, max(pr + 1 - a + minus, 0) +
max(0, a - pl))));
} else if (cr == cl + 1) {
int ans = max(1, min(minus, a - pl)) + min(a, pr + 1);
printf("%d\n", ans);
} else {
printf("%d\n", min(pr - pl + 1, max(1, a - pl)));
}
}
return 0;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
Polycarpus has a sequence, consisting of n non-negative integers: a1, a2, ..., an.
Let's define function f(l, r) (l, r are integer, 1 β€ l β€ r β€ n) for sequence a as an operation of bitwise OR of all the sequence elements with indexes from l to r. Formally: f(l, r) = al | al + 1 | ... | ar.
Polycarpus took a piece of paper and wrote out the values of function f(l, r) for all l, r (l, r are integer, 1 β€ l β€ r β€ n). Now he wants to know, how many distinct values he's got in the end.
Help Polycarpus, count the number of distinct values of function f(l, r) for the given sequence a.
Expression x | y means applying the operation of bitwise OR to numbers x and y. This operation exists in all modern programming languages, for example, in language C++ and Java it is marked as "|", in Pascal β as "or".
Input
The first line contains integer n (1 β€ n β€ 105) β the number of elements of sequence a. The second line contains n space-separated integers a1, a2, ..., an (0 β€ ai β€ 106) β the elements of sequence a.
Output
Print a single integer β the number of distinct values of function f(l, r) for the given sequence a.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use cin, cout streams or the %I64d specifier.
Examples
Input
3
1 2 0
Output
4
Input
10
1 2 3 4 5 6 1 2 9 10
Output
11
Note
In the first test case Polycarpus will have 6 numbers written on the paper: f(1, 1) = 1, f(1, 2) = 3, f(1, 3) = 3, f(2, 2) = 2, f(2, 3) = 2, f(3, 3) = 0. There are exactly 4 distinct numbers among them: 0, 1, 2, 3.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, num, numbers[100005], cant;
set<int> sol, aux;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &num);
cant = 0;
for (auto i = aux.begin(); i != aux.end(); i++) {
numbers[cant++] = (*i | num);
}
aux.clear();
numbers[cant++] = num;
aux.insert(numbers, numbers + cant);
sol.insert(aux.begin(), aux.end());
}
printf("%d\n", sol.size());
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
You are given a table consisting of n rows and m columns. Each cell of the table contains either 0 or 1. In one move, you are allowed to pick any row or any column and invert all values, that is, replace 0 by 1 and vice versa.
What is the minimum number of cells with value 1 you can get after applying some number of operations?
Input
The first line of the input contains two integers n and m (1 β€ n β€ 20, 1 β€ m β€ 100 000) β the number of rows and the number of columns, respectively.
Then n lines follows with the descriptions of the rows. Each line has length m and contains only digits '0' and '1'.
Output
Output a single integer β the minimum possible number of ones you can get after applying some sequence of operations.
Example
Input
3 4
0110
1010
0111
Output
2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 20;
const int M = 100100;
const int MOD = 998244353;
int add(int a, int b) { return (a + b) % MOD; }
int sub(int a, int b) { return (a - b + MOD) % MOD; }
int mul(int a, int b) { return (long long)a * b % MOD; }
int ksm(int a, int b) {
if (!b) return 1;
int x = ksm(a, b >> 1);
return mul(mul(x, x), b & 1 ? a : 1);
}
int inv(int a) { return ksm(a, MOD - 2); }
const int INV2 = inv(2);
void FWT(int *x, int n) {
if (n == 1) return;
int l = n >> 1;
FWT(x, l);
FWT(x + l, l);
for (int i = 0; i < l; i++) {
int &u = x[i], &v = x[l + i];
int uu = u, vv = v;
u = add(uu, vv);
v = sub(uu, vv);
}
}
void IFWT(int *x, int n) {
if (n == 1) return;
int l = n >> 1;
for (int i = 0; i < l; i++) {
int &u = x[i], &v = x[l + i];
int uu = u, vv = v;
u = mul(add(uu, vv), INV2);
v = mul(sub(uu, vv), INV2);
}
IFWT(x, l);
IFWT(x + l, l);
}
int n, m;
char s[N][M] = {'\0'};
int a[1 << N] = {0}, b[1 << N] = {0};
int pc(int x) { return x ? pc(x & (x - 1)) + 1 : 0; }
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
char &ch = s[i][j];
do {
ch = getchar();
} while (!isdigit(ch));
}
}
for (int i = 0; i < m; i++) {
int c = 0;
for (int j = 0; j < n; j++) {
c = (c << 1) | (s[j][i] ^ '0');
}
a[c]++;
}
int x = 1 << n;
for (int j = 0; j < x; j++) {
b[j] = min(pc(j), pc((x - 1) ^ j));
}
FWT(a, x);
FWT(b, x);
for (int i = 0; i < x; i++) {
a[i] = mul(a[i], b[i]);
}
IFWT(a, x);
int ans = INT_MAX;
for (int i = 0; i < x; i++) {
ans = min(ans, (int)a[i]);
}
printf("%d\n", ans);
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
You are given an integer x of n digits a_1, a_2, β¦, a_n, which make up its decimal notation in order from left to right.
Also, you are given a positive integer k < n.
Let's call integer b_1, b_2, β¦, b_m beautiful if b_i = b_{i+k} for each i, such that 1 β€ i β€ m - k.
You need to find the smallest beautiful integer y, such that y β₯ x.
Input
The first line of input contains two integers n, k (2 β€ n β€ 200 000, 1 β€ k < n): the number of digits in x and k.
The next line of input contains n digits a_1, a_2, β¦, a_n (a_1 β 0, 0 β€ a_i β€ 9): digits of x.
Output
In the first line print one integer m: the number of digits in y.
In the next line print m digits b_1, b_2, β¦, b_m (b_1 β 0, 0 β€ b_i β€ 9): digits of y.
Examples
Input
3 2
353
Output
3
353
Input
4 2
1234
Output
4
1313
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, k;
int a[200005];
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) {
scanf("%1d", &a[i]);
}
printf("%d\n", n);
bool ok = 1;
for (int i = k + 1; i <= n; ++i) {
if (a[i] < a[i - k]) {
break;
} else if (a[i] > a[i - k]) {
ok = 0;
break;
}
}
if (!ok) {
a[k]++;
for (int i = k; i >= 1; --i) {
if (a[i] >= 10) {
a[i] -= 10;
a[i - 1]++;
}
}
}
for (int i = 1; i <= n; ++i) {
if (i <= k) {
printf("%d", a[i]);
} else
printf("%d", a[i] = a[i - k]);
}
puts("");
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
There are n cities in Berland. Some pairs of cities are connected by roads. All roads are bidirectional. Each road connects two different cities. There is at most one road between a pair of cities. The cities are numbered from 1 to n.
It is known that, from the capital (the city with the number 1), you can reach any other city by moving along the roads.
The President of Berland plans to improve the country's road network. The budget is enough to repair exactly n-1 roads. The President plans to choose a set of n-1 roads such that:
* it is possible to travel from the capital to any other city along the n-1 chosen roads,
* if d_i is the number of roads needed to travel from the capital to city i, moving only along the n-1 chosen roads, then d_1 + d_2 + ... + d_n is minimized (i.e. as minimal as possible).
In other words, the set of n-1 roads should preserve the connectivity of the country, and the sum of distances from city 1 to all cities should be minimized (where you can only use the n-1 chosen roads).
The president instructed the ministry to prepare k possible options to choose n-1 roads so that both conditions above are met.
Write a program that will find k possible ways to choose roads for repair. If there are fewer than k ways, then the program should output all possible valid ways to choose roads.
Input
The first line of the input contains integers n, m and k (2 β€ n β€ 2β
10^5, n-1 β€ m β€ 2β
10^5, 1 β€ k β€ 2β
10^5), where n is the number of cities in the country, m is the number of roads and k is the number of options to choose a set of roads for repair. It is guaranteed that m β
k β€ 10^6.
The following m lines describe the roads, one road per line. Each line contains two integers a_i, b_i (1 β€ a_i, b_i β€ n, a_i β b_i) β the numbers of the cities that the i-th road connects. There is at most one road between a pair of cities. The given set of roads is such that you can reach any city from the capital.
Output
Print t (1 β€ t β€ k) β the number of ways to choose a set of roads for repair. Recall that you need to find k different options; if there are fewer than k of them, then you need to find all possible different valid options.
In the following t lines, print the options, one per line. Print an option as a string of m characters where the j-th character is equal to '1' if the j-th road is included in the option, and is equal to '0' if the road is not included. The roads should be numbered according to their order in the input. The options can be printed in any order. All the t lines should be different.
Since it is guaranteed that m β
k β€ 10^6, the total length of all the t lines will not exceed 10^6.
If there are several answers, output any of them.
Examples
Input
4 4 3
1 2
2 3
1 4
4 3
Output
2
1110
1011
Input
4 6 3
1 2
2 3
1 4
4 3
2 4
1 3
Output
1
101001
Input
5 6 2
1 2
1 3
2 4
2 5
3 4
3 5
Output
2
111100
110110
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <class U, class T>
void Max(U &first, T second) {
if (first < second) first = second;
}
template <class U, class T>
void Min(U &first, T second) {
if (first > second) first = second;
}
template <class T>
void add(int &a, T b) {
a = (a + b) % 998244353;
}
int pow(int a, int b) {
cerr << a << " " << b << "\n";
int ans = 1;
while (b) {
if (b & 1) ans = 1LL * ans * a % 998244353;
a = 1LL * a * a % 998244353;
b >>= 1;
}
return ans;
}
int vis[200010], n, K, d[200010];
string s;
vector<string> ans;
vector<pair<int, int> > g[200010], e[200010];
void dfs(int u) {
if (u == n) {
ans.push_back(s);
return;
}
for (auto &o : e[u]) {
s[o.second] = '1';
dfs(u + 1);
if (int(ans.size()) == K) return;
s[o.second] = '0';
}
}
int main() {
srand(time(NULL));
int T, ca = 0, m = 0, k, i, j;
scanf("%d%d%d", &n, &m, &K);
for (int i = 0; i < m; i++) {
scanf("%d%d", &j, &k);
j--, k--;
g[j].push_back({k, i}), g[k].push_back({j, i});
}
queue<int> q;
memset(d, -1, sizeof(d));
q.push(0);
d[0] = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
for (auto &o : g[u]) {
int v = o.first;
if (d[v] == -1) {
d[v] = d[u] + 1;
q.push(v);
}
}
}
for (int i = 0; i < n; i++) {
for (auto &o : g[i]) {
j = o.first;
if (d[j] == d[i] - 1) {
e[i].push_back({j, o.second});
}
}
}
for (int i = 0; i < m; i++) s += "0";
dfs(1);
printf("%d\n", int(ans.size()));
for (auto &s : ans) puts(s.c_str());
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
The protection of a popular program developed by one of IT City companies is organized the following way. After installation it outputs a random five digit number which should be sent in SMS to a particular phone number. In response an SMS activation code arrives.
A young hacker Vasya disassembled the program and found the algorithm that transforms the shown number into the activation code. Note: it is clear that Vasya is a law-abiding hacker, and made it for a noble purpose β to show the developer the imperfection of their protection.
The found algorithm looks the following way. At first the digits of the number are shuffled in the following order <first digit><third digit><fifth digit><fourth digit><second digit>. For example the shuffle of 12345 should lead to 13542. On the second stage the number is raised to the fifth power. The result of the shuffle and exponentiation of the number 12345 is 455 422 043 125 550 171 232. The answer is the 5 last digits of this result. For the number 12345 the answer should be 71232.
Vasya is going to write a keygen program implementing this algorithm. Can you do the same?
Input
The only line of the input contains a positive integer five digit number for which the activation code should be found.
Output
Output exactly 5 digits without spaces between them β the found activation code of the program.
Examples
Input
12345
Output
71232
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
char str[10];
long long num;
const long long MOD = 100000;
long long D(char ch) { return (long long)ch - (long long)'0'; }
void EnchomSolve() {
long long rem;
scanf("%s", str + 1);
num = D(str[1]);
num = num * 10 + D(str[3]);
num = num * 10 + D(str[5]);
num = num * 10 + D(str[4]);
num = num * 10 + D(str[2]);
rem = num;
num = num * rem * rem;
num %= MOD;
num = num * rem * rem;
num %= MOD;
if (num < 10000) printf("0");
if (num < 1000) printf("0");
if (num < 100) printf("0");
if (num < 10) printf("0");
printf("%lld\n", num);
return;
}
int main() {
EnchomSolve();
return 0;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
Paul is at the orchestra. The string section is arranged in an r Γ c rectangular grid and is filled with violinists with the exception of n violists. Paul really likes violas, so he would like to take a picture including at least k of them. Paul can take a picture of any axis-parallel rectangle in the orchestra. Count the number of possible pictures that Paul can take.
Two pictures are considered to be different if the coordinates of corresponding rectangles are different.
Input
The first line of input contains four space-separated integers r, c, n, k (1 β€ r, c, n β€ 10, 1 β€ k β€ n) β the number of rows and columns of the string section, the total number of violas, and the minimum number of violas Paul would like in his photograph, respectively.
The next n lines each contain two integers xi and yi (1 β€ xi β€ r, 1 β€ yi β€ c): the position of the i-th viola. It is guaranteed that no location appears more than once in the input.
Output
Print a single integer β the number of photographs Paul can take which include at least k violas.
Examples
Input
2 2 1 1
1 2
Output
4
Input
3 2 3 3
1 1
3 1
2 2
Output
1
Input
3 2 3 2
1 1
3 1
2 2
Output
4
Note
We will use '*' to denote violinists and '#' to denote violists.
In the first sample, the orchestra looks as follows
*#
**
Paul can take a photograph of just the viola, the 1 Γ 2 column containing the viola, the 2 Γ 1 row containing the viola, or the entire string section, for 4 pictures total.
In the second sample, the orchestra looks as follows
#*
*#
#*
Paul must take a photograph of the entire section.
In the third sample, the orchestra looks the same as in the second sample.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int r, c, n, k, a[12][12];
cin >> r >> c >> n >> k;
memset(a, 0, sizeof a);
for (int i = 0; i < n; i++) {
int t, tt;
cin >> t >> tt;
a[t][tt] = 1;
}
int b[12][12];
memset(b, 0, sizeof b);
for (int i = 1; i <= r; i++) {
for (int j = 1; j <= c; j++) {
b[i][j] = b[i][j - 1] + b[i - 1][j] + a[i][j] - b[i - 1][j - 1];
}
}
int ans = 0;
for (int i = 1; i <= r; i++) {
for (int ii = i; ii <= r; ii++) {
for (int j = 1; j <= c; j++) {
for (int jj = j; jj <= c; jj++) {
if (b[ii][jj] - b[i - 1][jj] - b[ii][j - 1] + b[i - 1][j - 1] >= k)
ans++;
}
}
}
}
cout << ans << endl;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
A positive integer may be expressed as a sum of different prime numbers (primes), in one way or another. Given two positive integers n and k, you should count the number of ways to express n as a sum of k different primes. Here, two ways are considered to be the same if they sum up the same set of the primes. For example, 8 can be expressed as 3 + 5 and 5+ 3 but they are not distinguished.
When n and k are 24 and 3 respectively, the answer is two because there are two sets {2, 3, 19} and {2, 5, 17} whose sums are equal to 24. There are no other sets of three primes that sum up to 24. For n = 24 and k = 2, the answer is three, because there are three sets {5, 19}, {7,17} and {11, 13}. For n = 2 and k = 1, the answer is one, because there is only one set {2} whose sum is 2. For n = 1 and k = 1, the answer is zero. As 1 is not a prime, you shouldn't count {1}. For n = 4 and k = 2, the answer is zero, because there are no sets of two diffrent primes whose sums are 4.
Your job is to write a program that reports the number of such ways for the given n and k.
Input
The input is a sequence of datasets followed by a line containing two zeros separated by a space. A dataset is a line containing two positive integers n and k separated by a space. You may assume that n β€ 1120 and k β€ 14.
Output
The output should be composed of lines, each corresponding to an input dataset. An output line should contain one non-negative integer indicating the number of ways for n and k specified in the corresponding dataset. You may assume that it is less than 231.
Example
Input
24 3
24 2
2 1
1 1
4 2
18 3
17 1
17 3
17 4
100 5
1000 10
1120 14
0 0
Output
2
3
1
0
0
2
1
0
1
55
200102899
2079324314
### Response
```cpp
#include <iostream>
#include <complex>
#include <sstream>
#include <string>
#include <algorithm>
#include <deque>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <vector>
#include <set>
#include <limits>
#include <cstdio>
#include <cctype>
#include <cmath>
#include <cstring>
#include <cstdlib>
#include <ctime>
using namespace std;
#define REP(i, j) for(int i = 0; i < (int)(j); ++i)
#define FOR(i, j, k) for(int i = (int)(j); i < (int)(k); ++i)
#define SORT(v) sort((v).begin(), (v).end())
#define REVERSE(v) reverse((v).begin(), (v).end())
typedef complex<double> P;
const int MAX_N = 1130;
const int MAX_K = 17;
bool p[MAX_N];
vector<int> vp;
void make_p(){
REP(i, MAX_N) p[i] = true;
p[0] = p[1] = false;
for(int i = 2; i < MAX_N; ++i){
if(!p[i]) continue;
vp.push_back(i);
for(int j = i + i; j < MAX_N; j += i) p[j] = false;
}
}
int main() {
make_p();
int N, K, dp[MAX_N][MAX_K];
memset(dp, 0, sizeof(dp));
REP(i, vp.size()){
int p = vp[i];
for(int k = MAX_K - 2; k >= 0; --k){
REP(n, MAX_N){
if(p + n >= MAX_N) break;
dp[n + p][k + 1] += dp[n][k];
}
}
dp[p][1] += 1;
}
while(cin >>N >>K && K) cout <<dp[N][K] <<endl;
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
We have a long seat of width X centimeters. There are many people who wants to sit here. A person sitting on the seat will always occupy an interval of length Y centimeters.
We would like to seat as many people as possible, but they are all very shy, and there must be a gap of length at least Z centimeters between two people, and between the end of the seat and a person.
At most how many people can sit on the seat?
Constraints
* All input values are integers.
* 1 \leq X, Y, Z \leq 10^5
* Y+2Z \leq X
Input
Input is given from Standard Input in the following format:
X Y Z
Output
Print the answer.
Examples
Input
13 3 1
Output
3
Input
12 3 1
Output
2
Input
100000 1 1
Output
49999
Input
64146 123 456
Output
110
Input
64145 123 456
Output
109
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(){
int n,a,b;
cin >> n >> a >> b;
cout << (n-b) / (a+b);
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
problem
AOR Ika is studying to pass the test.
AOR Ika-chan solved the $ N $ question. After that, round the solved problem according to the following procedure.
1. Check the correctness of the answer.
2. If the answer is correct, write a circle mark, and if it is incorrect, write a cross mark on the answer sheet.
AOR Ika faints because of the fear of failing the test the moment she finds that the answer is wrong for $ 2 $ in a row. And no further rounding is possible.
Syncope occurs between steps $ 1 $ and $ 2 $.
You will be given an integer $ N $, which represents the number of questions AOR Ika has solved, and a string $ S $, which is a length $ N $ and represents the correctness of the answer. The string consists of'o'and'x', with'o' indicating the correct answer and'x' indicating the incorrect answer. The $ i $ letter indicates the correctness of the $ i $ question, and AOR Ika-chan rounds the $ 1 $ question in order.
Please output the number of questions that AOR Ika-chan can write the correctness.
output
Output the number of questions that AOR Ika-chan could write in the $ 1 $ line. Also, output a line break at the end.
Example
Input
3
oxx
Output
2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main()
{
int N;
string S;
cin >> N;
cin >> S;
int ret = 0;
bool flip = false;
for(int i = 0; i < S.size(); i++) {
if(flip && S[i] == 'x') {
break;
} else if(S[i] == 'x') {
flip = true;
++ret;
} else {
++ret;
flip = false;
}
}
cout << ret << endl;
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
Dima took up the biology of bacteria, as a result of his experiments, he invented k types of bacteria. Overall, there are n bacteria at his laboratory right now, and the number of bacteria of type i equals ci. For convenience, we will assume that all the bacteria are numbered from 1 to n. The bacteria of type ci are numbered from <image> to <image>.
With the help of special equipment Dima can move energy from some bacteria into some other one. Of course, the use of such equipment is not free. Dima knows m ways to move energy from some bacteria to another one. The way with number i can be described with integers ui, vi and xi mean that this way allows moving energy from bacteria with number ui to bacteria with number vi or vice versa for xi dollars.
Dima's Chef (Inna) calls the type-distribution correct if there is a way (may be non-direct) to move energy from any bacteria of the particular type to any other bacteria of the same type (between any two bacteria of the same type) for zero cost.
As for correct type-distribution the cost of moving the energy depends only on the types of bacteria help Inna to determine is the type-distribution correct? If it is, print the matrix d with size k Γ k. Cell d[i][j] of this matrix must be equal to the minimal possible cost of energy-moving from bacteria with type i to bacteria with type j.
Input
The first line contains three integers n, m, k (1 β€ n β€ 105; 0 β€ m β€ 105; 1 β€ k β€ 500). The next line contains k integers c1, c2, ..., ck (1 β€ ci β€ n). Each of the next m lines contains three integers ui, vi, xi (1 β€ ui, vi β€ 105; 0 β€ xi β€ 104). It is guaranteed that <image>.
Output
If Dima's type-distribution is correct, print string Β«YesΒ», and then k lines: in the i-th line print integers d[i][1], d[i][2], ..., d[i][k] (d[i][i] = 0). If there is no way to move energy from bacteria i to bacteria j appropriate d[i][j] must equal to -1. If the type-distribution isn't correct print Β«NoΒ».
Examples
Input
4 4 2
1 3
2 3 0
3 4 0
2 4 1
2 1 2
Output
Yes
0 2
2 0
Input
3 1 2
2 1
1 2 0
Output
Yes
0 -1
-1 0
Input
3 2 2
2 1
1 2 0
2 3 1
Output
Yes
0 1
1 0
Input
3 0 2
1 2
Output
No
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int maxn = 1e5 + 5, maxk = 505, inf = 1e9 + 7;
bool vis[maxn];
int n, m, k, cur, id[maxn], c[maxk], cnt[maxk], color[maxn], d[maxk][maxk];
vector<int> vs[maxn];
void dfs(int v, int p = -1) {
vis[v] = true;
color[v] = cur;
for (int e : vs[v])
if (!vis[e]) dfs(e, v);
}
int main() {
scanf("%d %d %d", &n, &m, &k);
for (int i = 0; i < k; i++) {
fill(d[i], d[i] + k, inf);
scanf("%d", &c[i]);
if (c[i] == 1) d[i][i] = 0;
for (int j = 0; j < c[i]; j++) id[cur++] = i;
}
assert(cur == n);
for (int i = 0; i < m; i++) {
int x, y, w;
scanf("%d %d %d", &x, &y, &w);
x--, y--;
if (w == 0) {
vs[x].emplace_back(y);
vs[y].emplace_back(x);
}
x = id[x], y = id[y];
d[x][y] = d[y][x] = min(d[x][y], w);
}
cur = 0;
for (int i = 0; i < n; i++)
if (!vis[i]) {
cur++;
dfs(i);
}
cur = 0;
for (int i = 0; i < k; i++) {
bool all_equal = true;
int v = color[cur++];
for (int j = 1; j < c[i]; j++) all_equal &= (v == color[cur++]);
if (!all_equal) {
puts("No");
return 0;
}
}
assert(cur == n);
for (int l = 0; l < k; l++)
for (int i = 0; i < k; i++)
for (int j = 0; j < k; j++) d[i][j] = min(d[i][j], d[i][l] + d[l][j]);
puts("Yes");
for (int i = 0; i < k; i++) {
for (int j = 0; j < k; j++) {
printf("%d%c", d[i][j] >= inf ? -1 : d[i][j], " \n"[j + 1 == k]);
}
}
return 0;
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
After the big birthday party, Katie still wanted Shiro to have some more fun. Later, she came up with a game called treasure hunt. Of course, she invited her best friends Kuro and Shiro to play with her.
The three friends are very smart so they passed all the challenges very quickly and finally reached the destination. But the treasure can only belong to one cat so they started to think of something which can determine who is worthy of the treasure. Instantly, Kuro came up with some ribbons.
A random colorful ribbon is given to each of the cats. Each color of the ribbon can be represented as an uppercase or lowercase Latin letter. Let's call a consecutive subsequence of colors that appears in the ribbon a subribbon. The beauty of a ribbon is defined as the maximum number of times one of its subribbon appears in the ribbon. The more the subribbon appears, the more beautiful is the ribbon. For example, the ribbon aaaaaaa has the beauty of 7 because its subribbon a appears 7 times, and the ribbon abcdabc has the beauty of 2 because its subribbon abc appears twice.
The rules are simple. The game will have n turns. Every turn, each of the cats must change strictly one color (at one position) in his/her ribbon to an arbitrary color which is different from the unchanged one. For example, a ribbon aaab can be changed into acab in one turn. The one having the most beautiful ribbon after n turns wins the treasure.
Could you find out who is going to be the winner if they all play optimally?
Input
The first line contains an integer n (0 β€ n β€ 10^{9}) β the number of turns.
Next 3 lines contain 3 ribbons of Kuro, Shiro and Katie one per line, respectively. Each ribbon is a string which contains no more than 10^{5} uppercase and lowercase Latin letters and is not empty. It is guaranteed that the length of all ribbons are equal for the purpose of fairness. Note that uppercase and lowercase letters are considered different colors.
Output
Print the name of the winner ("Kuro", "Shiro" or "Katie"). If there are at least two cats that share the maximum beauty, print "Draw".
Examples
Input
3
Kuroo
Shiro
Katie
Output
Kuro
Input
7
treasurehunt
threefriends
hiCodeforces
Output
Shiro
Input
1
abcabc
cbabac
ababca
Output
Katie
Input
15
foPaErcvJ
mZaxowpbt
mkuOlaHRE
Output
Draw
Note
In the first example, after 3 turns, Kuro can change his ribbon into ooooo, which has the beauty of 5, while reaching such beauty for Shiro and Katie is impossible (both Shiro and Katie can reach the beauty of at most 4, for example by changing Shiro's ribbon into SSiSS and changing Katie's ribbon into Kaaaa). Therefore, the winner is Kuro.
In the fourth example, since the length of each of the string is 9 and the number of turn is 15, everyone can change their ribbons in some way to reach the maximal beauty of 9 by changing their strings into zzzzzzzzz after 9 turns, and repeatedly change their strings into azzzzzzzz and then into zzzzzzzzz thrice. Therefore, the game ends in a draw.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
char s[2 * (int)1e5 + 5];
int arr[130];
static int len;
int getMax() {
len = strlen(s);
int ret = 0;
memset(arr, 0, sizeof(arr));
for (int i = 0; i < len; i++) {
arr[s[i]]++;
ret = max(ret, arr[s[i]]);
}
return ret;
}
int main() {
int n;
scanf("%d", &n);
scanf("%s", s);
int kuro = getMax();
scanf("%s", s);
int shiro = getMax();
scanf("%s", s);
int katie = getMax();
if (kuro == len && n == 1 && len != 1)
kuro = len - 1;
else
kuro = min(len, kuro + n);
if (shiro == len && n == 1 && len != 1)
shiro = len - 1;
else
shiro = min(len, shiro + n);
if (katie == len && n == 1 && len != 1)
katie = len - 1;
else
katie = min(len, katie + n);
if (kuro > shiro && kuro > katie) {
printf("Kuro\n");
return 0;
}
if (shiro > kuro && shiro > katie) {
printf("Shiro\n");
return 0;
}
if (katie > kuro && katie > shiro) {
printf("Katie\n");
return 0;
}
printf("Draw\n");
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
Summer holidays! Someone is going on trips, someone is visiting grandparents, but someone is trying to get a part-time job. This summer Noora decided that she wants to earn some money, and took a job in a shop as an assistant.
Shop, where Noora is working, has a plan on the following n days. For each day sales manager knows exactly, that in i-th day ki products will be put up for sale and exactly li clients will come to the shop that day. Also, the manager is sure, that everyone, who comes to the shop, buys exactly one product or, if there aren't any left, leaves the shop without buying anything. Moreover, due to the short shelf-life of the products, manager established the following rule: if some part of the products left on the shelves at the end of the day, that products aren't kept on the next day and are sent to the dump.
For advertising purposes manager offered to start a sell-out in the shop. He asked Noora to choose any f days from n next for sell-outs. On each of f chosen days the number of products were put up for sale would be doubled. Thus, if on i-th day shop planned to put up for sale ki products and Noora has chosen this day for sell-out, shelves of the shop would keep 2Β·ki products. Consequently, there is an opportunity to sell two times more products on days of sell-out.
Noora's task is to choose f days to maximize total number of sold products. She asks you to help her with such a difficult problem.
Input
The first line contains two integers n and f (1 β€ n β€ 105, 0 β€ f β€ n) denoting the number of days in shop's plan and the number of days that Noora has to choose for sell-out.
Each line of the following n subsequent lines contains two integers ki, li (0 β€ ki, li β€ 109) denoting the number of products on the shelves of the shop on the i-th day and the number of clients that will come to the shop on i-th day.
Output
Print a single integer denoting the maximal number of products that shop can sell.
Examples
Input
4 2
2 1
3 5
2 3
1 5
Output
10
Input
4 1
0 2
0 3
3 5
0 6
Output
5
Note
In the first example we can choose days with numbers 2 and 4 for sell-out. In this case new numbers of products for sale would be equal to [2, 6, 2, 2] respectively. So on the first day shop will sell 1 product, on the second β 5, on the third β 2, on the fourth β 2. In total 1 + 5 + 2 + 2 = 10 product units.
In the second example it is possible to sell 5 products, if you choose third day for sell-out.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = int(300000) + 5;
long long int k, t, n, m, cnt, p, mx, sum, ans, cnt1;
long long int a[N], b[N], c[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
for (long long int i = 1; i <= n; i++) {
cin >> a[i] >> b[i];
c[i] = min(2 * a[i], b[i]) - min(a[i], b[i]);
}
sort(c + 1, c + 1 + n);
cnt = n;
for (long long int i = 1; i <= n; i++) {
if (i <= m) {
ans += c[cnt--];
}
ans += min(a[i], b[i]);
}
cout << ans;
return 0;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
You are given an H Γ W grid.
The squares in the grid are described by H strings, S_1,...,S_H.
The j-th character in the string S_i corresponds to the square at the i-th row from the top and j-th column from the left (1 \leq i \leq H,1 \leq j \leq W).
`.` stands for an empty square, and `#` stands for a square containing a bomb.
Dolphin is interested in how many bomb squares are horizontally, vertically or diagonally adjacent to each empty square.
(Below, we will simply say "adjacent" for this meaning. For each square, there are at most eight adjacent squares.)
He decides to replace each `.` in our H strings with a digit that represents the number of bomb squares adjacent to the corresponding empty square.
Print the strings after the process.
Constraints
* 1 \leq H,W \leq 50
* S_i is a string of length W consisting of `#` and `.`.
Input
Input is given from Standard Input in the following format:
H W
S_1
:
S_H
Output
Print the H strings after the process.
The i-th line should contain a string T_i of length W, where the j-th character in T_i corresponds to the square at the i-th row from the top and j-th row from the left in the grid (1 \leq i \leq H, 1 \leq j \leq W).
Examples
Input
3 5
.....
.#.#.
.....
Output
11211
1#2#1
11211
Input
3 5
Output
Input
6 6
.
.#.##
.#
.#..#.
.##..
.#...
Output
3
8#7##
5#
4#65#2
5##21
4#310
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
char k[51][51];
int s[51][51],n,m;
int a[8]={-1,-1,-1,0,0,1,1,1};
int b[8]={-1,0,1,-1,1,-1,0,1};
void dfs(int x,int y){
for(int i=0;i<8;i++){
int fx=x+a[i],fy=y+b[i];
if(fx<=n&&fy<=m&&fx>=1&&fy>=1&&k[fx][fy]=='#')
s[x][y]++;
}
}
int main(){
int i,j;
cin>>n>>m;
for(i=1;i<=n;i++)
for(j=1;j<=m;j++)
cin>>k[i][j];
for(i=1;i<=n;i++)
for(j=1;j<=m;j++)
if(k[i][j]=='.')dfs(i,j);
for(i=1;i<=n;i++){
for(j=1;j<=m;j++)
if(k[i][j]=='#')cout<<k[i][j];
else cout<<s[i][j];
cout<<endl;
}
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
Student Valera is an undergraduate student at the University. His end of term exams are approaching and he is to pass exactly n exams. Valera is a smart guy, so he will be able to pass any exam he takes on his first try. Besides, he can take several exams on one day, and in any order.
According to the schedule, a student can take the exam for the i-th subject on the day number ai. However, Valera has made an arrangement with each teacher and the teacher of the i-th subject allowed him to take an exam before the schedule time on day bi (bi < ai). Thus, Valera can take an exam for the i-th subject either on day ai, or on day bi. All the teachers put the record of the exam in the student's record book on the day of the actual exam and write down the date of the mark as number ai.
Valera believes that it would be rather strange if the entries in the record book did not go in the order of non-decreasing date. Therefore Valera asks you to help him. Find the minimum possible value of the day when Valera can take the final exam if he takes exams so that all the records in his record book go in the order of non-decreasing date.
Input
The first line contains a single positive integer n (1 β€ n β€ 5000) β the number of exams Valera will take.
Each of the next n lines contains two positive space-separated integers ai and bi (1 β€ bi < ai β€ 109) β the date of the exam in the schedule and the early date of passing the i-th exam, correspondingly.
Output
Print a single integer β the minimum possible number of the day when Valera can take the last exam if he takes all the exams so that all the records in his record book go in the order of non-decreasing date.
Examples
Input
3
5 2
3 1
4 2
Output
2
Input
3
6 1
5 2
4 3
Output
6
Note
In the first sample Valera first takes an exam in the second subject on the first day (the teacher writes down the schedule date that is 3). On the next day he takes an exam in the third subject (the teacher writes down the schedule date, 4), then he takes an exam in the first subject (the teacher writes down the mark with date 5). Thus, Valera takes the last exam on the second day and the dates will go in the non-decreasing order: 3, 4, 5.
In the second sample Valera first takes an exam in the third subject on the fourth day. Then he takes an exam in the second subject on the fifth day. After that on the sixth day Valera takes an exam in the first subject.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5005;
int n, a, b;
vector<pair<int, int> > v;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d%d", &a, &b);
v.push_back(make_pair(a, b));
}
sort(v.begin(), v.end());
int ans = v[0].second;
for (int i = 1; i < n; ++i) {
if (ans > v[i].second) {
if (v[i].first > ans) ans = v[i].first;
} else
ans = v[i].second;
}
printf("%d\n", ans);
return 0;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
You are given the set of vectors on the plane, each of them starting at the origin. Your task is to find a pair of vectors with the minimal non-oriented angle between them.
Non-oriented angle is non-negative value, minimal between clockwise and counterclockwise direction angles. Non-oriented angle is always between 0 and Ο. For example, opposite directions vectors have angle equals to Ο.
Input
First line of the input contains a single integer n (2 β€ n β€ 100 000) β the number of vectors.
The i-th of the following n lines contains two integers xi and yi (|x|, |y| β€ 10 000, x2 + y2 > 0) β the coordinates of the i-th vector. Vectors are numbered from 1 to n in order of appearing in the input. It is guaranteed that no two vectors in the input share the same direction (but they still can have opposite directions).
Output
Print two integer numbers a and b (a β b) β a pair of indices of vectors with the minimal non-oriented angle. You can print the numbers in any order. If there are many possible answers, print any.
Examples
Input
4
-1 0
0 -1
1 0
1 1
Output
3 4
Input
6
-1 0
0 -1
1 0
1 1
-4 -5
-4 -6
Output
6 5
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long null = 0;
struct segment;
struct line;
struct point;
struct vec;
struct ray;
struct point {
long double x, y;
point() {}
point(long double x1, long double y1) {
x = x1;
y = y1;
}
long double dist_to_point(point p) {
return sqrt((p.x - x) * (p.x - x) + (p.y - y) * (p.y - y));
}
bool operator<(point p) { return (x < p.x) || ((x == p.x) && (y < p.y)); }
};
struct vec {
long double x, y;
vec(long double x1, long double y1) {
x = x1;
y = y1;
}
vec(point a, point b) {
x = b.x - a.x;
y = b.y - a.y;
}
vec normal() {
vec ans;
ans.x = y;
ans.y = -x;
return ans;
}
vec opposite() {
vec ans;
ans.x = -x;
ans.y = -y;
return ans;
}
vec sum(vec b) {
vec ans;
ans.x = x + b.x;
ans.y = y + b.y;
return ans;
}
long double cross_product(vec v) { return x * v.y - v.x * y; }
long double dot_product(vec v) { return x * v.x + y * v.y; }
vec resize(long double size) {
vec ans;
ans.x = (x * size) / len();
ans.y = (y * size) / len();
return ans;
}
vec() {}
long double len() { return sqrt(x * x + y * y); }
};
struct line {
long double a, b, c;
line(point a1, point b1) {
a = a1.y - b1.y;
b = b1.x - a1.x;
c = -a1.x * a - a1.y * b;
}
line(long double a1, long double b1, long double c1) {
a = a1;
b = b1;
c = c1;
}
line() {}
vec normal_vec() {
vec ans;
ans.x = a;
ans.y = b;
return ans;
}
line normal_line(point p) {
line ans;
ans.a = -b;
ans.b = a;
ans.c = -ans.a * p.x - ans.b * p.y;
return ans;
}
long double get_x(long double y1) {
if (a == 0) return 0;
return (-c - b * y1) / a;
}
long double get_y(long double x1) {
if (b == 0) return 0;
return (-c - a * x1) / b;
}
point intersection(line l) {
point ans;
ans.x = (-c * l.b + l.c * b) / (a * l.b - l.a * b);
ans.y = (-a * l.c + l.a * c) / (a * l.b - l.a * b);
return ans;
}
bool parallels(line l) { return a * l.b - l.a * b == 0; }
long double dist_to_point(point p) {
return abs((a * p.x + b * p.y + c) / (sqrt(a * a + b * b)));
}
long long is_inside(point p) {
long double k = a * p.x + b * p.y + c;
if (k < 0)
return -1;
else if (k == 0)
return 0;
return 1;
}
};
struct segment {
point a, b;
segment() {}
segment(point a1, point b1) {
a = a1;
b = b1;
}
long double len() {
return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}
bool is_inside(point p) {
line l(a, b);
if (l.is_inside(p) != 0) return false;
vec v(p, a), v1(p, b);
if (v.dot_product(v1) > 0) return false;
return true;
}
long double dist_to_point(point p) {
vec v(a, p), v1(a, b), v2(b, p), v3(b, a);
if (v.dot_product(v1) < 0) return p.dist_to_point(a);
if (v2.dot_product(v3) < 0) return p.dist_to_point(b);
line l(a, b);
return l.dist_to_point(p);
}
point get_center() {
point ans;
ans.x = (a.x + b.x) / 2;
ans.y = (a.y + b.y) / 2;
return ans;
}
};
struct ray {
point a, b;
ray(point p, point p1) {
a = p;
b = p1;
}
ray() {}
long double dist_to_point(point p) {
vec v(a, p), v1(a, b);
if (v.dot_product(v1) < 0) return a.dist_to_point(p);
line l(a, b);
return l.dist_to_point(p);
}
bool is_inside(point p) {
line l(a, b);
if (l.is_inside(p) != 0) return false;
vec v(a, p), v1(a, b);
if (v.dot_product(v1) < 0) return false;
return true;
}
};
struct angle {
point a, b, c;
angle(){};
angle(point a1, point b1, point c1) {
a = a1;
b = b1;
c = c1;
}
long double get_angle() {
vec v(b, a), v1(b, c);
return acos(v.dot_product(v1) / (v.len() * v1.len()));
}
long double get_grad_angle() {
vec v(b, a), v1(b, c);
return 180 * acos(v.dot_product(v1) / (v.len() * v1.len())) /
3.141592653589793238462643;
}
};
struct polygon {
long long n;
vector<point> points;
long double get_area() {
point a(0, 0);
vec v(a, points[0]);
long double ans = 0;
for (long long i = 1; i < n; ++i) {
vec v1(a, points[i]);
ans = ans + v.cross_product(v1);
v = v1;
}
vec v2(a, points[0]);
vec v1(a, points[n - 1]);
return abs(ans + v1.cross_product(v2)) / 2;
}
};
struct triangle {
point a, b, c;
triangle() {}
triangle(point a1, point b1, point c1) {
a = a1;
b = b1;
c = c1;
}
long double get_area() {
point d(0, 0);
vec v(a, d), v1(b, d), v2(c, d);
return (v.cross_product(v1) + v1.cross_product(v2) + v2.cross_product(v)) /
2;
}
point get_center() {
segment s(a, b), s1(a, c);
point p = s.get_center(), p1 = s1.get_center();
line l(a, b), l1(a, c), l2(b, c);
l = l.normal_line(p);
l1 = l1.normal_line(p1);
return l.intersection(l1);
}
long double get_R() {
triangle t(a, b, c);
point p = t.get_center();
return p.dist_to_point(a);
}
};
long long power(long long a, long long b) {
if (b == 0)
return 1;
else if (b == 1)
return a;
else {
long long k = power(a, b / 2);
return k * k * power(a, b % 2);
}
}
long long power_mod(long long a, long long b, long long MOD) {
if (b == 0)
return 1;
else if (b == 1)
return a % MOD;
else {
long long k = power_mod(a, b / 2, MOD);
return ((k * k) % MOD * power_mod(a, b % 2, MOD)) % MOD;
}
}
long long sum_mod(long long a, long long b, long long MOD) {
return (a + b) % MOD;
}
long long mul_mod(long long a, long long b, long long MOD) {
return (a * b) % MOD;
}
long long ord(char a) { return a; }
char chr(long long a) { return a; }
long long strtoint(string s) {
long long ans = 0;
for (long long i = 0; i < s.size(); ++i) {
ans *= 10;
ans += ord(s[i]) - 48;
}
return ans;
}
string rev_string(string s) {
string ans = "";
for (long long i = s.size(); i >= 0; --i) {
ans += s[i];
}
return ans;
}
string inttostr(long long a) {
string ans = "", ans1 = "";
while (a > 0) {
ans += chr(a % 10 + 48);
a /= 10;
}
for (long long i = ans.size() - 1; i >= 0; --i) {
ans1 += ans[i];
}
return ans1;
}
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long nok(long long a, long long b) { return a * b / gcd(a, b); }
struct new_struct {
long long i;
long double a;
};
bool f(new_struct a, new_struct b) { return a.a < b.a; }
vector<new_struct> ar;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
srand(time(0));
long long n;
cin >> n;
for (long long i = 0; i < n; ++i) {
long long x, y;
cin >> x >> y;
new_struct k;
k.a = atan2(y, x);
if (k.a < 0) k.a += 2 * 3.141592653589793238462643;
k.i = i;
ar.push_back(k);
}
sort(ar.begin(), ar.end(), f);
long double mi = 2 * 3.141592653589793238462643 + ar[0].a - ar[n - 1].a,
mi_i = ar[0].i, mi_i1 = ar[n - 1].i;
for (long long i = 1; i < n; ++i) {
if (ar[i].a - ar[i - 1].a < mi) {
mi = ar[i].a - ar[i - 1].a;
mi_i = ar[i].i;
mi_i1 = ar[i - 1].i;
}
}
cout << mi_i + 1 << " " << mi_i1 + 1;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
Gerald has n younger brothers and their number happens to be even. One day he bought n2 candy bags. One bag has one candy, one bag has two candies, one bag has three candies and so on. In fact, for each integer k from 1 to n2 he has exactly one bag with k candies.
Help him give n bags of candies to each brother so that all brothers got the same number of candies.
Input
The single line contains a single integer n (n is even, 2 β€ n β€ 100) β the number of Gerald's brothers.
Output
Let's assume that Gerald indexes his brothers with numbers from 1 to n. You need to print n lines, on the i-th line print n integers β the numbers of candies in the bags for the i-th brother. Naturally, all these numbers should be distinct and be within limits from 1 to n2. You can print the numbers in the lines in any order.
It is guaranteed that the solution exists at the given limits.
Examples
Input
2
Output
1 4
2 3
Note
The sample shows Gerald's actions if he has two brothers. In this case, his bags contain 1, 2, 3 and 4 candies. He can give the bags with 1 and 4 candies to one brother and the bags with 2 and 3 to the other brother.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
for (int i = 0, _n = (int)(n); i < _n; i++) {
for (int j = 0, _n = (int)(n); j < _n; j++)
cout << n * j + 1 + (i + j + 1) % n << " ";
cout << endl;
}
return 0;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
You are fishing with polar bears Alice and Bob. While waiting for the fish to bite, the polar bears get bored. They come up with a game. First Alice and Bob each writes a 01-string (strings that only contain character "0" and "1") a and b. Then you try to turn a into b using two types of operations:
* Write parity(a) to the end of a. For example, <image>.
* Remove the first character of a. For example, <image>. You cannot perform this operation if a is empty.
You can use as many operations as you want. The problem is, is it possible to turn a into b?
The parity of a 01-string is 1 if there is an odd number of "1"s in the string, and 0 otherwise.
Input
The first line contains the string a and the second line contains the string b (1 β€ |a|, |b| β€ 1000). Both strings contain only the characters "0" and "1". Here |x| denotes the length of the string x.
Output
Print "YES" (without quotes) if it is possible to turn a into b, and "NO" (without quotes) otherwise.
Examples
Input
01011
0110
Output
YES
Input
0011
1110
Output
NO
Note
In the first sample, the steps are as follows: 01011 β 1011 β 011 β 0110
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
string a, b;
int aL, bL;
bool check(int pos) {
if (aL - pos > bL) return false;
int ch = 0, par;
for (int i = 0; i < pos; i++) {
if (a[i] == '1') ch++;
}
par = ch % 2;
for (int i = pos; i < aL; i++) {
if (a[i] == '1') par++;
}
par = par % 2;
for (int i = pos; i < aL; i++)
if (a[i] != b[i - pos]) return false;
int i = aL - pos;
while (i < bL) {
if (par == b[i] - '0') {
i++;
par = 0;
} else {
if (ch == 0) return false;
ch--;
par = (par + 1) % 2;
}
}
return true;
}
int main() {
cin >> a >> b;
aL = a.length();
bL = b.length();
for (int i = 0; i < aL + 1; i++) {
if (check(i)) {
cout << "YES" << endl;
return 0;
}
}
int par = 0;
for (int i = 0; i < aL; i++)
if (a[i] == '1') par++;
par %= 2;
if (par) a = a + "1";
aL = a.length();
for (int i = 0; i < aL + 1; i++) {
if (check(i)) {
cout << "YES" << endl;
return 0;
}
}
cout << "NO" << endl;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
Just to remind, girls in Arpa's land are really nice.
Mehrdad wants to invite some Hoses to the palace for a dancing party. Each Hos has some weight wi and some beauty bi. Also each Hos may have some friends. Hoses are divided in some friendship groups. Two Hoses x and y are in the same friendship group if and only if there is a sequence of Hoses a1, a2, ..., ak such that ai and ai + 1 are friends for each 1 β€ i < k, and a1 = x and ak = y.
<image>
Arpa allowed to use the amphitheater of palace to Mehrdad for this party. Arpa's amphitheater can hold at most w weight on it.
Mehrdad is so greedy that he wants to invite some Hoses such that sum of their weights is not greater than w and sum of their beauties is as large as possible. Along with that, from each friendship group he can either invite all Hoses, or no more than one. Otherwise, some Hoses will be hurt. Find for Mehrdad the maximum possible total beauty of Hoses he can invite so that no one gets hurt and the total weight doesn't exceed w.
Input
The first line contains integers n, m and w (1 β€ n β€ 1000, <image>, 1 β€ w β€ 1000) β the number of Hoses, the number of pair of friends and the maximum total weight of those who are invited.
The second line contains n integers w1, w2, ..., wn (1 β€ wi β€ 1000) β the weights of the Hoses.
The third line contains n integers b1, b2, ..., bn (1 β€ bi β€ 106) β the beauties of the Hoses.
The next m lines contain pairs of friends, the i-th of them contains two integers xi and yi (1 β€ xi, yi β€ n, xi β yi), meaning that Hoses xi and yi are friends. Note that friendship is bidirectional. All pairs (xi, yi) are distinct.
Output
Print the maximum possible total beauty of Hoses Mehrdad can invite so that no one gets hurt and the total weight doesn't exceed w.
Examples
Input
3 1 5
3 2 5
2 4 2
1 2
Output
6
Input
4 2 11
2 4 6 6
6 4 2 1
1 2
2 3
Output
7
Note
In the first sample there are two friendship groups: Hoses {1, 2} and Hos {3}. The best way is to choose all of Hoses in the first group, sum of their weights is equal to 5 and sum of their beauty is 6.
In the second sample there are two friendship groups: Hoses {1, 2, 3} and Hos {4}. Mehrdad can't invite all the Hoses from the first group because their total weight is 12 > 11, thus the best way is to choose the first Hos from the first group and the only one from the second group. The total weight will be 8, and the total beauty will be 7.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1005;
vector<int> B;
vector<int> W;
int dp[MAXN][MAXN];
vector<int> g[MAXN];
int bi[MAXN];
int wi[MAXN];
int totalB;
int totalW;
bool visited[MAXN];
vector<int> component[MAXN];
int cur_component;
void dfs(int x) {
if (visited[x]) return;
totalB += bi[x];
totalW += wi[x];
visited[x] = true;
component[cur_component].push_back(x);
for (int i = 0; i < g[x].size(); i++) {
dfs(g[x][i]);
}
}
int main() {
int n, m, w;
cin >> n >> m >> w;
for (int i = 1; i <= n; i++) {
cin >> wi[i];
}
for (int i = 1; i <= n; i++) {
cin >> bi[i];
}
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
if (!visited[i]) {
totalB = 0;
totalW = 0;
dfs(i);
B.push_back(totalB);
W.push_back(totalW);
cur_component++;
}
}
for (int j = 0; j <= w; j++) {
dp[0][j] = -1;
}
if (W[0] <= w) dp[0][W[0]] = B[0];
for (int i = 0; i < component[0].size(); i++) {
dp[0][wi[component[0][i]]] =
max(dp[0][wi[component[0][i]]], bi[component[0][i]]);
}
dp[0][0] = 0;
for (int i = 1; i < B.size(); i++) {
for (int j = 0; j <= w; j++) {
dp[i][j] = dp[i - 1][j];
}
for (int j = 0; j < w; j++) {
if (dp[i - 1][j] != -1 && j + W[i] <= w)
dp[i][j + W[i]] = max(dp[i][j + W[i]], dp[i - 1][j] + B[i]);
for (int k = 0; k < component[i].size(); k++) {
if (dp[i - 1][j] != -1 && j + wi[component[i][k]] <= w)
dp[i][j + wi[component[i][k]]] =
max(dp[i][j + wi[component[i][k]]],
dp[i - 1][j] + bi[component[i][k]]);
}
}
}
int ans = 0;
for (int j = 0; j <= w; j++) {
ans = max(ans, dp[B.size() - 1][j]);
}
cout << ans;
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
Cheaterius is a famous in all the Berland astrologist, magician and wizard, and he also is a liar and a cheater. One of his latest inventions is Cheaterius' amulets! They bring luck and wealth, but are rather expensive. Cheaterius makes them himself. The technology of their making is kept secret. But we know that throughout long nights Cheaterius glues together domino pairs with super glue to get squares 2 Γ 2 which are the Cheaterius' magic amulets!
<image> That's what one of Cheaterius's amulets looks like
After a hard night Cheaterius made n amulets. Everyone of them represents a square 2 Γ 2, every quarter contains 1 to 6 dots. Now he wants sort them into piles, every pile must contain similar amulets. Two amulets are called similar if they can be rotated by 90, 180 or 270 degrees so that the following condition is met: the numbers of dots in the corresponding quarters should be the same. It is forbidden to turn over the amulets.
Write a program that by the given amulets will find the number of piles on Cheaterius' desk.
Input
The first line contains an integer n (1 β€ n β€ 1000), where n is the number of amulets. Then the amulet's descriptions are contained. Every description occupies two lines and contains two numbers (from 1 to 6) in each line. Between every pair of amulets the line "**" is located.
Output
Print the required number of piles.
Examples
Input
4
31
23
**
31
23
**
13
32
**
32
13
Output
1
Input
4
51
26
**
54
35
**
25
61
**
45
53
Output
2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
bool used[1001];
char c[1001][3][3], z;
string s, sr, st;
set<char> second;
pair<int, string> pr[100001];
vector<long long> v, vc;
map<string, int> mp;
long long d[1000001];
long long ar[1000001];
long long n, m, b, a, cnt = 1, ans, mn = 99999999999;
bool check(int x, int y) {
bool mon = 0;
if (c[x][1][1] == c[y][1][1] && c[x][1][2] == c[y][1][2] &&
c[x][2][1] == c[y][2][1] && c[x][2][2] == c[y][2][2])
mon = 1;
if (c[x][1][1] == c[y][1][2] && c[x][1][2] == c[y][2][2] &&
c[x][2][2] == c[y][2][1] && c[x][2][1] == c[y][1][1])
mon = 1;
if (c[x][1][1] == c[y][2][2] && c[x][1][2] == c[y][2][1] &&
c[x][2][1] == c[y][1][2] && c[x][2][2] == c[y][1][1])
mon = 1;
if (c[x][1][1] == c[y][2][1] && c[x][2][1] == c[y][2][2] &&
c[x][2][2] == c[y][1][2] && c[x][1][2] == c[y][1][1])
mon = 1;
return mon;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> c[i][1][1] >> c[i][1][2];
cin >> c[i][2][1] >> c[i][2][2];
if (i != n) cin >> z >> z;
}
for (int i = 1; i <= n; i++) {
if (used[i] == 1) continue;
used[i] = 1;
ans++;
for (int j = 1; j <= n; j++) {
if (check(i, j) == 1 && used[j] == 0) used[j] = 1;
}
}
cout << ans;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
Kuroni has n daughters. As gifts for them, he bought n necklaces and n bracelets:
* the i-th necklace has a brightness a_i, where all the a_i are pairwise distinct (i.e. all a_i are different),
* the i-th bracelet has a brightness b_i, where all the b_i are pairwise distinct (i.e. all b_i are different).
Kuroni wants to give exactly one necklace and exactly one bracelet to each of his daughters. To make sure that all of them look unique, the total brightnesses of the gifts given to each daughter should be pairwise distinct. Formally, if the i-th daughter receives a necklace with brightness x_i and a bracelet with brightness y_i, then the sums x_i + y_i should be pairwise distinct. Help Kuroni to distribute the gifts.
For example, if the brightnesses are a = [1, 7, 5] and b = [6, 1, 2], then we may distribute the gifts as follows:
* Give the third necklace and the first bracelet to the first daughter, for a total brightness of a_3 + b_1 = 11.
* Give the first necklace and the third bracelet to the second daughter, for a total brightness of a_1 + b_3 = 3.
* Give the second necklace and the second bracelet to the third daughter, for a total brightness of a_2 + b_2 = 8.
Here is an example of an invalid distribution:
* Give the first necklace and the first bracelet to the first daughter, for a total brightness of a_1 + b_1 = 7.
* Give the second necklace and the second bracelet to the second daughter, for a total brightness of a_2 + b_2 = 8.
* Give the third necklace and the third bracelet to the third daughter, for a total brightness of a_3 + b_3 = 7.
This distribution is invalid, as the total brightnesses of the gifts received by the first and the third daughter are the same. Don't make them this upset!
Input
The input consists of multiple test cases. The first line contains an integer t (1 β€ t β€ 100) β the number of test cases. The description of the test cases follows.
The first line of each test case contains a single integer n (1 β€ n β€ 100) β the number of daughters, necklaces and bracelets.
The second line of each test case contains n distinct integers a_1, a_2, ..., a_n (1 β€ a_i β€ 1000) β the brightnesses of the necklaces.
The third line of each test case contains n distinct integers b_1, b_2, ..., b_n (1 β€ b_i β€ 1000) β the brightnesses of the bracelets.
Output
For each test case, print a line containing n integers x_1, x_2, ..., x_n, representing that the i-th daughter receives a necklace with brightness x_i. In the next line print n integers y_1, y_2, ..., y_n, representing that the i-th daughter receives a bracelet with brightness y_i.
The sums x_1 + y_1, x_2 + y_2, ..., x_n + y_n should all be distinct. The numbers x_1, ..., x_n should be equal to the numbers a_1, ..., a_n in some order, and the numbers y_1, ..., y_n should be equal to the numbers b_1, ..., b_n in some order.
It can be shown that an answer always exists. If there are multiple possible answers, you may print any of them.
Example
Input
2
3
1 8 5
8 4 5
3
1 7 5
6 1 2
Output
1 8 5
8 4 5
5 1 7
6 2 1
Note
In the first test case, it is enough to give the i-th necklace and the i-th bracelet to the i-th daughter. The corresponding sums are 1 + 8 = 9, 8 + 4 = 12, and 5 + 5 = 10.
The second test case is described in the statement.
### Response
```cpp
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
using namespace std;
const long long mod = 1e9;
const int phash = 3;
const long long modhash = 1000000000000000003;
int main() {
ios_base::sync_with_stdio(false);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
vector<int> b(n);
for (int i = 0; i < n; i++) cin >> b[i];
sort(a.begin(), a.end());
sort(b.begin(), b.end());
for (int i : a) cout << i << " ";
cout << '\n';
for (int i : b) cout << i << " ";
cout << '\n';
}
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
You are given sequence a1, a2, ..., an and m queries lj, rj (1 β€ lj β€ rj β€ n). For each query you need to print the minimum distance between such pair of elements ax and ay (x β y), that:
* both indexes of the elements lie within range [lj, rj], that is, lj β€ x, y β€ rj;
* the values of the elements are equal, that is ax = ay.
The text above understands distance as |x - y|.
Input
The first line of the input contains a pair of integers n, m (1 β€ n, m β€ 5Β·105) β the length of the sequence and the number of queries, correspondingly.
The second line contains the sequence of integers a1, a2, ..., an ( - 109 β€ ai β€ 109).
Next m lines contain the queries, one per line. Each query is given by a pair of numbers lj, rj (1 β€ lj β€ rj β€ n) β the indexes of the query range limits.
Output
Print m integers β the answers to each query. If there is no valid match for some query, please print -1 as an answer to this query.
Examples
Input
5 3
1 1 2 3 2
1 5
2 4
3 5
Output
1
-1
2
Input
6 5
1 2 1 3 2 3
4 6
1 3
2 5
2 4
1 6
Output
2
2
3
-1
2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct Pair {
int x, position;
} valiue[543211], b[543211];
int n, k, len, N, Partition, L, R;
int QWER[543211], REWQ[543211], otvet[543211], kol, i;
int Lowofbound[543211], Behind[543211], sled[543211], l, r, mn;
vector<pair<pair<int, int>, int> > a[800];
bool cmd(Pair q, Pair w) {
if (q.position < w.position)
return true;
else
return false;
}
bool cmp(Pair q, Pair w) {
if (q.x < w.x)
return true;
else
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> k;
for (i = 1; i <= n; ++i) {
cin >> valiue[i].x;
b[i].position = i;
b[i].x = valiue[i].x;
}
sort(b + 1, b + n + 1, cmp);
len = 0;
for (i = 1; i <= n; ++i) {
if (i == 1 || b[i].x != b[i - 1].x) {
++len;
}
valiue[i].x = len;
valiue[i].position = b[i].position;
}
sort(valiue + 1, valiue + n + 1, cmd);
N = int(sqrt(n));
for (i = 1; i <= k; ++i) {
cin >> l >> r;
Partition = (l - 1) / N + 1;
a[Partition].push_back(make_pair(make_pair(r, l), i));
}
for (i = 1; i <= n; ++i) {
if (!QWER[valiue[i].x])
QWER[valiue[i].x] = i;
else
Behind[i] = QWER[valiue[i].x], QWER[valiue[i].x] = i;
}
for (i = n; i >= 1; --i) {
if (!REWQ[valiue[i].x])
REWQ[valiue[i].x] = i;
else
sled[i] = REWQ[valiue[i].x], REWQ[valiue[i].x] = i;
}
for (i = 1; i <= n; ++i) Lowofbound[(i - 1) / N + 1] = i;
for (i = 1; i <= 720; ++i)
if (a[i].size() > 0) {
sort(a[i].begin(), a[i].end());
mn = 2000000000;
R = Lowofbound[i];
L = R + 1;
for (int j = 0; j < a[i].size(); ++j) {
l = a[i][j].first.second;
r = a[i][j].first.first;
if (L <= r) {
while (R < r) {
R++;
if (Behind[R] > Lowofbound[i]) mn = min(mn, R - Behind[R]);
}
kol = mn;
for (int c = Lowofbound[i]; c >= l; --c)
if (sled[c] > 0 && sled[c] <= R) kol = min(kol, sled[c] - c);
} else {
kol = mn;
for (int c = l; c <= r; ++c)
if (sled[c] > 0 && sled[c] <= r) kol = min(kol, sled[c] - c);
}
if (kol != 2000000000)
otvet[a[i][j].second] = kol;
else
otvet[a[i][j].second] = -1;
}
}
for (i = 1; i <= k; ++i) cout << otvet[i] << endl;
return 0;
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
I: Ravage
Santa Claus was caught in the illuminations of the city and broke it.
There are N light bulbs in the illumination, and the $ i $ th light bulb only comes on when the voltage is above $ A_i $ and below $ B_i $.
The voltage should be the same everywhere in the illumination.
Find out how many light bulbs can be lit at the same time by adjusting the voltage.
input
The integer $ N $ is given on the first line.
Of the following $ N $ lines, $ A_i and B_i $ are given on the $ i $ line, separated by blanks.
output
Output the maximum number of light bulbs that can be illuminated at the same time.
Constraint
* $ N $ is an integer greater than or equal to $ 1 $ and less than or equal to $ 100 \ 000 $
* $ A_1, A_2, A_3, \ dots, A_N $ are integers greater than or equal to $ 1 $ and less than or equal to $ 1 \ 000 \ 000 \ 000 $
* $ B_1, B_2, B_3, \ dots, B_N $ are integers greater than or equal to $ 1 $ and less than or equal to $ 1 \ 000 \ 000 \ 000 $
* Satisfy $ A_i \ leq B_i $ for all light bulbs $ i $
Input example 1
Four
14
3 6
2 7
5 8
Output example 1
3
When the voltage is $ 5 $ or $ 3.14 $, there are $ 3 $ bulbs.
Input example 2
2
1 2
twenty three
Output example 2
2
Example
Input
4
1 4
3 6
2 7
5 8
Output
3
### Response
```cpp
#include "bits/stdc++.h"
using namespace std;
int n,a,s;
int main(){map<int,int>m;cin>>n;for(int i=0;i<n;++i){int a,b;cin>>a>>b;++m[a];--m[b];}for(auto i:m){s+=i.second;a=max(a,s);}cout<<a<<endl;}
``` |
### Prompt
Generate 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>
int C[5], N, M;
int min(int a, int b) { return a < b ? a : b; }
int main() {
int tmp, t = 0, b = 0, ans;
for (int i = 1; i <= 4; i++) scanf("%d", &C[i]);
scanf("%d%d", &N, &M);
for (int i = 1; i <= N; i++) {
scanf("%d", &tmp);
b += min(C[1] * tmp, C[2]);
}
for (int i = 1; i <= M; i++) {
scanf("%d", &tmp);
t += min(C[1] * tmp, C[2]);
}
ans = C[4];
if (C[3] + b < ans) ans = C[3] + b;
if (C[3] + t < ans) ans = C[3] + t;
if (C[3] + C[3] < ans) ans = C[3] + C[3];
if (b + t < ans) ans = b + t;
printf("%d\n", ans);
return 0;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
Ichihime is the current priestess of the Mahjong Soul Temple. She claims to be human, despite her cat ears.
These days the temple is holding a math contest. Usually, Ichihime lacks interest in these things, but this time the prize for the winner is her favorite β cookies. Ichihime decides to attend the contest. Now she is solving the following problem.
<image>
You are given four positive integers a, b, c, d, such that a β€ b β€ c β€ d.
Your task is to find three integers x, y, z, satisfying the following conditions:
* a β€ x β€ b.
* b β€ y β€ c.
* c β€ z β€ d.
* There exists a triangle with a positive non-zero area and the lengths of its three sides are x, y, and z.
Ichihime desires to get the cookie, but the problem seems too hard for her. Can you help her?
Input
The first line contains a single integer t (1 β€ t β€ 1000) β the number of test cases.
The next t lines describe test cases. Each test case is given as four space-separated integers a, b, c, d (1 β€ a β€ b β€ c β€ d β€ 10^9).
Output
For each test case, print three integers x, y, z β the integers you found satisfying the conditions given in the statement.
It is guaranteed that the answer always exists. If there are multiple answers, print any.
Example
Input
4
1 3 5 7
1 5 5 7
100000 200000 300000 400000
1 1 977539810 977539810
Output
3 4 5
5 5 5
182690 214748 300999
1 977539810 977539810
Note
One of the possible solutions to the first test case:
<image>
One of the possible solutions to the second test case:
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t, a, b, c, d;
cin >> t;
while (t--) {
cin >> a >> b >> c >> d;
cout << b << " " << c << " " << c << endl;
}
return 0;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
We have a tree with N vertices and N-1 edges, respectively numbered 1, 2,\cdots, N and 1, 2, \cdots, N-1. Edge i connects Vertex u_i and v_i.
For integers L, R (1 \leq L \leq R \leq N), let us define a function f(L, R) as follows:
* Let S be the set of the vertices numbered L through R. f(L, R) represents the number of connected components in the subgraph formed only from the vertex set S and the edges whose endpoints both belong to S.
Compute \sum_{L=1}^{N} \sum_{R=L}^{N} f(L, R).
Constraints
* 1 \leq N \leq 2 \times 10^5
* 1 \leq u_i, v_i \leq N
* The given graph is a tree.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
u_1 v_1
u_2 v_2
:
u_{N-1} v_{N-1}
Output
Print \sum_{L=1}^{N} \sum_{R=L}^{N} f(L, R).
Examples
Input
3
1 3
2 3
Output
7
Input
2
1 2
Output
3
Input
10
5 3
5 7
8 9
1 9
9 10
8 4
7 4
6 10
7 2
Output
113
### Response
```cpp
#include<iostream>
#include<cstdio>
using namespace std;
typedef long long LL;
int main(){
//freopen(".in","r",stdin);
//freopen(".out","w",stdout);
int n;
cin>>n;
LL ans=0;
for(int i=1;i<=n;i++){
ans+=1ll*i*(n-i+1);
}
for(int i=1;i<n;i++){
int u,v;
scanf("%d%d",&u,&v);
if(u>v){
swap(u,v);
}
ans-=1ll*u*(n-v+1);
}
cout<<ans<<endl;
return 0;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
Given n integers a1, a2,β¦, an and n integers p1, p2,β¦, pn, integer m. The operation of selecting the kth integer ak with a probability of pk [%] is performed for each k (1 β€ k β€ n), and 0 or more and n or less integers are selected. Find the expected number of integers between 1 and m that are divisible by at least one of the selected integers.
Constraints
* 1 β€ n β€ 20
* 1 β€ m β€ 1018
* 1 β€ ak β€ 1018 (1 β€ k β€ n)
* 1 β€ pk β€ 99 (1 β€ k β€ n)
Input
The input is given in the following format.
> n m
> a1 a2β¦ an
> p1 p2β¦ pn
>
Output
Print the solution to the problem on one line. The output must not have an absolute or relative error of more than 0.0000001 (= 10-7).
Examples
Input
2 15
3 5
50 50
Output
3.75
Input
4 100
2 3 5 7
80 60 40 20
Output
57.352
Input
4 210
2 3 5 7
80 60 40 20
Output
119.9136
### Response
```cpp
#include <cstdio>
#include <iostream>
#include <vector>
#include <list>
#include <cmath>
#include <fstream>
#include <algorithm>
#include <string>
#include <queue>
#include <set>
#include <map>
#include <complex>
#include <iterator>
#include <cstdlib>
#include <cstring>
#include <sstream>
#include <stack>
#include <climits>
#include <deque>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
double EPS=1e-10;
double EQ(double a,double b){
return abs(a-b)<EPS;
}
void fast_stream(){
cin.tie(0);
std::ios_base::sync_with_stdio(0);
}
template<class T>
string IntToString(T num){
string res;stringstream ss;ss<<num;
return ss.str();
}
ll StringToInt(string &str){
ll res=0;
for(int i=0;i<(int)str.size();i++)
res=(res*10+str[i]-'0');
return res;
}
int N;
ll M;
ll as[101];
double ps[101];
ll gcd(ll a,ll b){
if(b==0)return a;
return gcd(b,a%b);
}
ll lcm(ll a,ll b){
return a/gcd(a,b)*b;
}
long double lcm2(ll a,ll b){
return 1.0*a*b/gcd(a,b);
}
int main(){
cin>>N>>M;
for(int i=0;i<N;i++)cin>>as[i];
for(int i=0;i<N;i++){
cin>>ps[i];
ps[i]/=100;
}
double res=0;
for(int i=1;i<(1<<N);i++){
double per=1;
int bitCnt=__builtin_popcount(i);
ll m=1;
for(int j=0;j<N;j++){
if((i>>j)&1){
// Mγγ₯γΌγι³γ¨γγ€γ²γγ€γΉγγ₯γ‘fin
double d=lcm2(m,as[j]);
//cout<<i<<" "<<j<<" "<<m<<" "<<as[j]<<" "<<d<<endl;
if(lcm2(m,as[j])>M){
m=M+1;
break;
}
//cout<<m<<" "<<as[j]<<endl;
m=lcm(m,as[j]);
//cout<<m<<endl;
per*=ps[j];
}
}
//cout<<res<<" "<<m<<endl;
if(!(bitCnt%2))res-=per*(M/m);
else res+=per*(M/m);
}
printf("%.10f\n",res);
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
Hamed has recently found a string t and suddenly became quite fond of it. He spent several days trying to find all occurrences of t in other strings he had. Finally he became tired and started thinking about the following problem. Given a string s how many ways are there to extract k β₯ 1 non-overlapping substrings from it such that each of them contains string t as a substring? More formally, you need to calculate the number of ways to choose two sequences a1, a2, ..., ak and b1, b2, ..., bk satisfying the following requirements:
* k β₯ 1
* <image>
* <image>
* <image>
* <image> t is a substring of string saisai + 1... sbi (string s is considered as 1-indexed).
As the number of ways can be rather large print it modulo 109 + 7.
Input
Input consists of two lines containing strings s and t (1 β€ |s|, |t| β€ 105). Each string consists of lowercase Latin letters.
Output
Print the answer in a single line.
Examples
Input
ababa
aba
Output
5
Input
welcometoroundtwohundredandeightytwo
d
Output
274201
Input
ddd
d
Output
12
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
string s, t;
int pi[100050], N, M, sum[100050], sum2[100050], pr[100050], K = 0, dp[100050];
void make_prefix() {
int i, q = 0;
for (i = 2, pi[1] = 0; i <= M; i++) {
while (q && t[q + 1] != t[i]) q = pi[q];
if (t[q + 1] == t[i]) ++q;
pi[i] = q;
}
}
int main() {
cin >> s;
cin.ignore();
cin >> t;
int i, q = 0, l, r, mid;
N = s.length();
M = t.length();
for (i = N; i > 0; i--) s[i] = s[i - 1];
for (i = M; i > 0; i--) t[i] = t[i - 1];
make_prefix();
for (i = 1; i <= N; i++) {
while (q && t[q + 1] != s[i]) q = pi[q];
if (t[q + 1] == s[i]) q++;
if (q == M) {
q = pi[M];
pr[++K] = i - M + 1;
}
}
dp[0] = 1;
sum[0] = 1;
sum2[0] = 1;
for (i = 1; i <= N; i++) {
l = 1, r = K;
if (i - pr[1] + 1 < M) {
sum[i] = sum[i - 1];
sum2[i] = (sum[i] + sum2[i - 1]) % 1000000007LL;
continue;
}
while (r - l > 1) {
mid = (l + r) / 2;
if (i - pr[mid] + 1 < M)
r = mid - 1;
else
l = mid;
}
if (i - pr[l + 1] + 1 >= M && l + 1 <= K) l++;
dp[i] = sum2[pr[l] - 1];
sum[i] = (sum[i - 1] + dp[i]) % 1000000007LL;
sum2[i] = (sum2[i - 1] + sum[i]) % 1000000007LL;
}
cout << (sum[N] - 1 + 1000000007LL) % 1000000007LL;
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Paul is at the orchestra. The string section is arranged in an r Γ c rectangular grid and is filled with violinists with the exception of n violists. Paul really likes violas, so he would like to take a picture including at least k of them. Paul can take a picture of any axis-parallel rectangle in the orchestra. Count the number of possible pictures that Paul can take.
Two pictures are considered to be different if the coordinates of corresponding rectangles are different.
Input
The first line of input contains four space-separated integers r, c, n, k (1 β€ r, c, n β€ 10, 1 β€ k β€ n) β the number of rows and columns of the string section, the total number of violas, and the minimum number of violas Paul would like in his photograph, respectively.
The next n lines each contain two integers xi and yi (1 β€ xi β€ r, 1 β€ yi β€ c): the position of the i-th viola. It is guaranteed that no location appears more than once in the input.
Output
Print a single integer β the number of photographs Paul can take which include at least k violas.
Examples
Input
2 2 1 1
1 2
Output
4
Input
3 2 3 3
1 1
3 1
2 2
Output
1
Input
3 2 3 2
1 1
3 1
2 2
Output
4
Note
We will use '*' to denote violinists and '#' to denote violists.
In the first sample, the orchestra looks as follows
*#
**
Paul can take a photograph of just the viola, the 1 Γ 2 column containing the viola, the 2 Γ 1 row containing the viola, or the entire string section, for 4 pictures total.
In the second sample, the orchestra looks as follows
#*
*#
#*
Paul must take a photograph of the entire section.
In the third sample, the orchestra looks the same as in the second sample.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
bool a[11][11];
int main() {
int R, C, N, K;
scanf("%d%d%d%d", &R, &C, &N, &K);
for (int i = 0; i < N; i++) {
int y, x;
scanf("%d%d", &y, &x);
y--;
x--;
a[y][x] = true;
}
int ans = 0;
for (int i = 0; i < R; i++) {
for (int j = 0; j < C; j++) {
for (int r = 1; r <= R; r++) {
if (i + r > R) break;
for (int c = 1; c <= C; c++) {
if (j + c > C) break;
int cur = 0;
for (int p = 0; p < r; p++)
for (int q = 0; q < c; q++) cur += a[i + p][j + q];
if (cur >= K) ans++;
}
}
}
}
printf("%d", ans);
return 0;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
In Republic of Atcoder, there are N prefectures, and a total of M cities that belong to those prefectures.
City i is established in year Y_i and belongs to Prefecture P_i.
You can assume that there are no multiple cities that are established in the same year.
It is decided to allocate a 12-digit ID number to each city.
If City i is the x-th established city among the cities that belong to Prefecture i, the first six digits of the ID number of City i is P_i, and the last six digits of the ID number is x.
Here, if P_i or x (or both) has less than six digits, zeros are added to the left until it has six digits.
Find the ID numbers for all the cities.
Note that there can be a prefecture with no cities.
Constraints
* 1 \leq N \leq 10^5
* 1 \leq M \leq 10^5
* 1 \leq P_i \leq N
* 1 \leq Y_i \leq 10^9
* Y_i are all different.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
P_1 Y_1
:
P_M Y_M
Output
Print the ID numbers for all the cities, in ascending order of indices (City 1, City 2, ...).
Examples
Input
2 3
1 32
2 63
1 12
Output
000001000002
000002000001
000001000001
Input
2 3
2 55
2 77
2 99
Output
000002000001
000002000002
000002000003
### Response
```cpp
#include<vector>
#include<algorithm>
#include<cstdio>
using namespace std;
int main(){
int N, M, P[100010], Y[100010];
vector< vector<int> > p(100010);
scanf("%d %d", &N, &M);
for(int i = 0;i < M;i++){
scanf("%d %d", &P[i], &Y[i]);
p[P[i]].push_back(Y[i]);
}
for(int i = 1;i <= N;i++) sort(p[i].begin(), p[i].end());
for(int i = 0;i < M;i++) printf("%06d%06d\n", P[i], int(lower_bound(p[P[i]].begin(), p[P[i]].end(), Y[i]) - p[P[i]].begin()) + 1);
return 0;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
Two deer, AtCoDeer and TopCoDeer, are playing a game called Honest or Dishonest. In this game, an honest player always tells the truth, and an dishonest player always tell lies. You are given two characters a and b as the input. Each of them is either `H` or `D`, and carries the following information:
If a=`H`, AtCoDeer is honest; if a=`D`, AtCoDeer is dishonest. If b=`H`, AtCoDeer is saying that TopCoDeer is honest; if b=`D`, AtCoDeer is saying that TopCoDeer is dishonest.
Given this information, determine whether TopCoDeer is honest.
Constraints
* a=`H` or a=`D`.
* b=`H` or b=`D`.
Input
The input is given from Standard Input in the following format:
a b
Output
If TopCoDeer is honest, print `H`. If he is dishonest, print `D`.
Examples
Input
H H
Output
H
Input
D H
Output
D
Input
D D
Output
H
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
string a,b;
cin >> a >> b;
if((a==b))cout<<"H"<<endl;
else cout<<"D"<<endl;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
Let's denote d(n) as the number of divisors of a positive integer n. You are given three integers a, b and c. Your task is to calculate the following sum:
<image>
Find the sum modulo 1073741824 (230).
Input
The first line contains three space-separated integers a, b and c (1 β€ a, b, c β€ 100).
Output
Print a single integer β the required sum modulo 1073741824 (230).
Examples
Input
2 2 2
Output
20
Input
5 6 7
Output
1520
Note
For the first example.
* d(1Β·1Β·1) = d(1) = 1;
* d(1Β·1Β·2) = d(2) = 2;
* d(1Β·2Β·1) = d(2) = 2;
* d(1Β·2Β·2) = d(4) = 3;
* d(2Β·1Β·1) = d(2) = 2;
* d(2Β·1Β·2) = d(4) = 3;
* d(2Β·2Β·1) = d(4) = 3;
* d(2Β·2Β·2) = d(8) = 4.
So the result is 1 + 2 + 2 + 3 + 2 + 3 + 3 + 4 = 20.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
const int primes[25] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41,
43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97};
int pfc[101][25] = {0};
for (int i = 1; i <= 100; ++i) {
int ii = i;
for (int j = 0; ii != 1 && j < 25; ++j) {
while (ii % primes[j] == 0) {
pfc[i][j] += 1;
ii /= primes[j];
}
}
}
int a, b, c, answer(0);
cin >> a >> b >> c;
for (int i = 1; i <= a; ++i) {
for (int j = 1; j <= b; ++j) {
for (int k = 1; k <= c; ++k) {
int divisors = 1;
for (int d = 0; d < 25; ++d) {
divisors *= (1 + pfc[i][d] + pfc[j][d] + pfc[k][d]);
}
answer += divisors;
}
}
}
answer %= 1073741824;
cout << answer << endl;
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
Ninja Atsushi guards the town from the roof of the Ninja Building from early morning to late night every day. This Ninja Building is two adjacent buildings of the same floor, and Atsushi's daily routine is to jump between buildings and head to the rooftop for security.
Because these two buildings are cleaned frequently, there are ladders and slippery areas that can help you climb the building. Moreover, the position of ladders and slippery parts changes every day. Therefore, Atsushi has to think about how to get to the roof every day.
Atsushi jumps over the walls of two buildings of the same floor, aiming for the rooftop of the building. Jumps can be started on the first floor of either building. When jumping to the opposite building, you can jump to the same floor, one floor up, or two floors up.
There are three types of walls, and the movement after jumping to each wall is decided.
* 0. Ordinary wall: Do not move up and down. The next jump will be made from there.
* 1. Ladder: The ladder spans two or more floors and moves to the top of the current ladder. The next jump will be made from there.
* 2. Sliding wall: A normal wall or slides down to the top of the ladder. The next jump will be made from there.
Also, the walls run from the first floor to the top floor just below the roof, and the roof can only be reached from the top floor of the building. Also, the wall on the bottom floor of the building will not be a slippery wall.
Create a program that takes in the number of floors n of the two buildings and the type of wall of the two buildings, and outputs the minimum number of jumps to reach the top floor and reach the rooftop. You may reach the roof of either building. However, if Atsushi cannot reach the roof of either building, please output "NA".
<image>
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
n
a1 a2 ... an
b1 b2 ... bn
The first line gives the building floor n (3 β€ n β€ 100). The second line gives the wall information ai from the first floor to the nth floor of the first building, and the third line gives the wall information bi from the first floor to the nth floor of the second building. ai and bi represent the information of the wall on the i-th floor, 0 is the ordinary wall, 1 is the ladder (straddling the i-th floor and the i + 1-floor), and 2 is the sliding wall.
The number of datasets does not exceed 60.
Output
Outputs the number of jumps on one line for each input dataset.
Example
Input
8
0 0 0 2 2 2 0 0
1 1 1 1 0 0 0 0
4
1 1 2 2
0 0 2 2
0
Output
4
NA
### Response
```cpp
#include "bits/stdc++.h"
#include<unordered_map>
#include<unordered_set>
#pragma warning(disable:4996)
using namespace std;
using ld = long double;
const ld eps = 1e-9;
//// < "d:\d_download\visual studio 2015\projects\programing_contest_c++\debug\a.txt" > "d:\d_download\visual studio 2015\projects\programing_contest_c++\debug\b.txt"
struct aa {
int y;
int x;
int time;
};
int main() {
while (1) {
int N; cin >> N;
if (!N)break;
vector<vector<int>>walls(N, vector<int>(2));
vector<vector<int>>memo(N, vector<int>(2, 10000));
for (int y = 0; y < 2; ++y) {
for (int i = 0; i < N; ++i) {
cin >> walls[i][y];
}
}
queue<aa>que;
memo[0][0] = 0;
que.push(aa{ 0,0,0 });
que.push(aa{ 0,1,0 });
memo[0][1] = 0;
int ans = -1;
while (!que.empty()) {
auto atop(que.front());
que.pop();
if (atop.y == N - 1) {
ans = atop.time;
break;
}
while (walls[atop.y][atop.x] == 1 && walls[atop.y+1][atop.x] == 1) {
atop.y++;
if (atop.y == N - 1) {
ans = atop.time;
break;
}
}
if (atop.y == N - 1) {
ans = atop.time;
break;
}
for (int dy = 0; dy <= 2; ++dy) {
int ny = atop.y + dy;
if (ny >= N)continue;
int nx = !atop.x;
while (walls[ny][nx] == 2) {
ny--;
}
if (memo[ny][nx]>atop.time + 1) {
memo[ny][nx] = atop.time + 1;
que.push(aa{ ny,nx,atop.time + 1 });
}
}
}
if (ans == -1)cout << "NA" << endl;
else cout << ans << endl;
}
return 0;
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
According to a new ISO standard, a flag of every country should have a chequered field n Γ m, each square should be of one of 10 colours, and the flag should be Β«stripedΒ»: each horizontal row of the flag should contain squares of the same colour, and the colours of adjacent horizontal rows should be different. Berland's government asked you to find out whether their flag meets the new ISO standard.
Input
The first line of the input contains numbers n and m (1 β€ n, m β€ 100), n β the amount of rows, m β the amount of columns on the flag of Berland. Then there follows the description of the flag: each of the following n lines contain m characters. Each character is a digit between 0 and 9, and stands for the colour of the corresponding square.
Output
Output YES, if the flag meets the new ISO standard, and NO otherwise.
Examples
Input
3 3
000
111
222
Output
YES
Input
3 3
000
000
111
Output
NO
Input
3 3
000
111
002
Output
NO
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
char A[n][m];
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) cin >> A[i][j];
bool flag = true;
for (int i = 0; i < n; ++i)
for (int j = 1; j < m; ++j) flag &= (A[i][j] == A[i][j - 1]);
for (int i = 1; i < n; ++i) flag &= (A[i][0] != A[i - 1][0]);
if (flag)
cout << "YES";
else
cout << "NO";
return 0;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
You are playing a solitaire puzzle called "Connect", which uses several letter tiles.
There are R Γ C empty cells. For each i (1 β€ i β€ R), you must put a string si (1 β€ |si| β€ C) in the i-th row of the table, without changing the letter order. In other words, you choose an integer sequence {aj} such that 1 β€ a1 < a2 < ... < a|si| β€ C , and put the j-th character of the string si in the aj-th column (1 β€ j β€ |si|).
For example, when C = 8 and si = "ICPC", you can put si like followings.
I_C_P_C_
ICPC____
_IC___PC
'_' represents an empty cell.
For each non-empty cell x, you get a point equal to the number of adjacent cells which have the same character as x. Two cells are adjacent if they share an edge.
Calculate the maximum total point you can get.
Input
The first line contains two integers R and C (1 β€ R β€ 128, 1 β€ C β€ 16).
Then R lines follow, each of which contains si (1 β€ |si| β€ C). All characters of si are uppercase letters.
Output
Output the maximum total point in a line.
Examples
Input
2 4
ACM
ICPC
Output
2
Input
2 9
PROBLEMF
CONNECT
Output
6
Input
4 16
INTERNATIONAL
COLLEGIATE
PROGRAMMING
CONTEST
Output
18
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main()
{
int R, C;
string S[128];
int hash[1 << 16];
for(int i = 0; i < 1 << 16; i++) hash[i] = __builtin_popcount(i);
cin >> R >> C;
for(int i = 0; i < R; i++) cin >> S[i];
vector< int > latte(1 << C, -1);
latte[0] = 0;
const int mask = (1 << C) - 1;
for(int y = 0; y < R; y++) {
for(int x = 0; x < C; x++) {
vector< int > malta(1 << C, -1);
for(int j = 0; j < 1 << C; j++) {
if(latte[j] == -1) continue;
auto ch = [&](int &a, int b)
{
a = max(a, b);
};
const int beet = hash[j & ((1 << x) - 1)];
if(beet + C - x > S[y].size()) ch(malta[j & ~(1 << x)], latte[j]);
if(beet < S[y].size()) {
int point = 0;
if(x && (j >> (x - 1)) & 1) {
if(beet && S[y][beet] == S[y][beet - 1]) ++point;
}
if(y && (j >> x) & 1) {
int pos = (int) S[y - 1].size() - hash[j >> x];
if(pos >= 0 && S[y - 1][pos] == S[y][beet]) ++point;
}
ch(malta[j | (1 << x)], latte[j] + point);
}
}
latte = malta;
}
}
cout << *max_element(begin(latte), end(latte)) * 2 << endl;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
On the Internet, data is divided into packets, and each packet is transferred to a destination via a relay device called a router. Each router determines the next router to forward from the destination described in the packet. In addition, a value called TTL (Time To Live) is added to the packet to prevent it from being forwarded between routers indefinitely. The router subtracts 1 from the TTL of the received packet, discards the packet if the result is 0, and forwards it to the next router otherwise.
So I decided to create a program to help design the network. Create a program that takes the network connection information and the outbound packet information as input and displays the minimum number of routers that each packet goes through before arriving at the destination router.
The network consists of multiple routers and cables connecting them as shown in the figure. However, keep in mind that each connection (cable) is unidirectional. An array of router numbers to which each router is directly connected is given as network connection information. If the number of routers is n, then each router is identified by an integer from 1 to n. If there are multiple routes from the source to the destination router, output the value with the smaller number of routers. If the packet does not reach the destination, output NA.
For example, consider a network like the one shown below with 6 source routers and 5 destination routers. The shortest route is 6 β 1 β 5, and there are 3 routers to go through. In this case, the TTL is subtracted by routers 6 and 1, respectively, so the packet can be reached if the TTL at the time of transmission is 3 or more. The destination router does not need to subtract the TTL. Also, it is assumed that there is no packet whose source and destination are the same router.
<image>
Input
The input is given in the following format:
n
r1 k1 t11 t12 ... t1 k1
r2 k2 t21 t22 ... t2 k2
::
rn kn tn1 tn2 ... tnkn
p
s1 d1 v1
s2 d2 v2
::
sp dp vp
The first line gives the total number of routers n (n β€ 100), and the following n lines give the connection information for the i-th router. The connection information is given the i-th router number ri, the number of routers directly connected to the i-th router ki, and the router numbers ti1, ti2, ... tiki that can be sent from the i-th router.
The following line gives the number of packets p (p β€ 1000), and the following p line gives the information of the i-th packet. The information in the packet is given the source router number si, the destination router number di, and the TTL value vi (0 β€ vi β€ 10000).
Output
For each packet, output the number of routers or NA to pass through on one line.
Example
Input
7
1 4 2 5 4 3
2 1 5
3 1 6
4 1 7
5 2 7 6
6 1 1
7 0
6
1 2 2
1 5 3
1 2 1
5 1 3
6 3 3
1 7 4
Output
2
2
NA
3
3
3
### Response
```cpp
#include <iostream>
#include <queue>
#include <map>
#include <climits>
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
typedef pair<int,int> NODE;
#define pos first
#define depth second
bool info[100][100];
int bfs(int s,int d){
queue<NODE> Q;
bool done[100]={false};
Q.push( make_pair(s,0) );
while( !Q.empty() ){
/* queueγγ₯ειγ²γη£γ§γγ₯εγγγΌγγγγ₯γΌγθ¨ͺγε§ͺγγε¬ζΈγ₯ζγ₯ε―γ€γͺγγ₯owγιζΈιζΏγ₯ε―η¦Ώγ·γγ₯γ§γγγγγΞ΄γΌγγ€γ₯γγ₯γ‘γε²γ²γγ₯γ£γζΈζ
γ€γ₯ */
NODE now = Q.front();
Q.pop();
done[now.pos] = true;
if(now.pos == d){
return now.depth;
}
for(int next=0;next<100;next++){
if( !done[next] && info[now.pos][next] ){
Q.push( make_pair(next,now.depth+1) );
}
}
}
return INT_MAX;
}
int main(){
int n,r,k,t,p,s,d,v;
cin >> n;
for(int i=0;i<n;i++){
cin >> r >> k;
r--;
for(int j=0;j<k;j++){
cin >> t;
t--;
info[r][t] = true;
}
}
cin >> p;
for(int i=0;i<p;i++){
cin >> s >> d >> v;
s--;d--;
if(v > bfs(s,d) )cout << bfs(s,d)+1 << endl;
else cout << "NA" << endl;
}
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
Sherlock Holmes found a mysterious correspondence of two VIPs and made up his mind to read it. But there is a problem! The correspondence turned out to be encrypted. The detective tried really hard to decipher the correspondence, but he couldn't understand anything.
At last, after some thought, he thought of something. Let's say there is a word s, consisting of |s| lowercase Latin letters. Then for one operation you can choose a certain position p (1 β€ p < |s|) and perform one of the following actions:
* either replace letter sp with the one that alphabetically follows it and replace letter sp + 1 with the one that alphabetically precedes it;
* or replace letter sp with the one that alphabetically precedes it and replace letter sp + 1 with the one that alphabetically follows it.
Let us note that letter "z" doesn't have a defined following letter and letter "a" doesn't have a defined preceding letter. That's why the corresponding changes are not acceptable. If the operation requires performing at least one unacceptable change, then such operation cannot be performed.
Two words coincide in their meaning iff one of them can be transformed into the other one as a result of zero or more operations.
Sherlock Holmes needs to learn to quickly determine the following for each word: how many words can exist that coincide in their meaning with the given word, but differs from the given word in at least one character? Count this number for him modulo 1000000007 (109 + 7).
Input
The input data contains several tests. The first line contains the only integer t (1 β€ t β€ 104) β the number of tests.
Next t lines contain the words, one per line. Each word consists of lowercase Latin letters and has length from 1 to 100, inclusive. Lengths of words can differ.
Output
For each word you should print the number of different other words that coincide with it in their meaning β not from the words listed in the input data, but from all possible words. As the sought number can be very large, print its value modulo 1000000007 (109 + 7).
Examples
Input
1
ab
Output
1
Input
1
aaaaaaaaaaa
Output
0
Input
2
ya
klmbfxzb
Output
24
320092793
Note
Some explanations about the operation:
* Note that for each letter, we can clearly define the letter that follows it. Letter "b" alphabetically follows letter "a", letter "c" follows letter "b", ..., "z" follows letter "y".
* Preceding letters are defined in the similar manner: letter "y" precedes letter "z", ..., "a" precedes letter "b".
* Note that the operation never changes a word's length.
In the first sample you can obtain the only other word "ba". In the second sample you cannot obtain any other word, so the correct answer is 0.
Consider the third sample. One operation can transform word "klmbfxzb" into word "klmcexzb": we should choose p = 4, and replace the fourth letter with the following one ("b" β "c"), and the fifth one β with the preceding one ("f" β "e"). Also, we can obtain many other words from this one. An operation can transform word "ya" only into one other word "xb".
Word "ya" coincides in its meaning with words "xb", "wc", "vd", ..., "ay" (overall there are 24 other words). The word "klmbfxzb has many more variants β there are 3320092814 other words that coincide with in the meaning. So the answer for the first word equals 24 and for the second one equals 320092793 β the number 3320092814 modulo 109 + 7
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100 + 20, MAXS = 2600 + 200, M = 1000 * 1000 * 1000 + 7;
long long d[MAXN][MAXS];
int main() {
int t;
cin >> t;
for (int i = 0; i < 101; i++)
for (int j = i + 1; j <= (i + 1) * 26; j++) {
for (int k = 1; k <= min(j, 26); k++) {
if (i == 0 && j <= 26)
d[i][j] = 1;
else if (i != 0)
d[i][j] += d[i - 1][j - k];
d[i][j] %= M;
}
}
while (t--) {
long long sum = 0;
string s;
cin >> s;
for (int i = 0; i < s.size(); i++) sum += s[i] - 'a' + 1;
cout << d[s.size() - 1][sum] - 1 << endl;
}
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
You are given a permutation p of numbers 1, 2, ..., n. Let's define f(p) as the following sum:
<image>
Find the lexicographically m-th permutation of length n in the set of permutations having the maximum possible value of f(p).
Input
The single line of input contains two integers n and m (1 β€ m β€ cntn), where cntn is the number of permutations of length n with maximum possible value of f(p).
The problem consists of two subproblems. The subproblems have different constraints on the input. You will get some score for the correct submission of the subproblem. The description of the subproblems follows.
* In subproblem B1 (3 points), the constraint 1 β€ n β€ 8 will hold.
* In subproblem B2 (4 points), the constraint 1 β€ n β€ 50 will hold.
Output
Output n number forming the required permutation.
Examples
Input
2 2
Output
2 1
Input
3 2
Output
1 3 2
Note
In the first example, both permutations of numbers {1, 2} yield maximum possible f(p) which is equal to 4. Among them, (2, 1) comes second in lexicographical order.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long arr[60];
int pos[60];
void func(int st, int l, int r, long long m) {
if (l == r) {
pos[l] = st;
return;
}
int n = r - l + 1;
if (m <= arr[n - 1]) {
pos[l] = st;
func(st + 1, l + 1, r, m);
} else {
pos[r] = st;
func(st + 1, l, r - 1, m - arr[n - 1]);
}
}
int main() {
long long n, m;
scanf("%I64d %I64d", &n, &m);
arr[1] = 1;
for (int i = 2; i <= n; ++i) {
arr[i] = 2 * arr[i - 1];
}
func(1, 0, n - 1, m);
for (int i = 0; i < n; ++i) {
printf("%d ", pos[i]);
}
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
It is known that passages in Singer house are complex and intertwined. Let's define a Singer k-house as a graph built by the following process: take complete binary tree of height k and add edges from each vertex to all its successors, if they are not yet present.
<image> Singer 4-house
Count the number of non-empty paths in Singer k-house which do not pass the same vertex twice. Two paths are distinct if the sets or the orders of visited vertices are different. Since the answer can be large, output it modulo 109 + 7.
Input
The only line contains single integer k (1 β€ k β€ 400).
Output
Print single integer β the answer for the task modulo 109 + 7.
Examples
Input
2
Output
9
Input
3
Output
245
Input
20
Output
550384565
Note
There are 9 paths in the first example (the vertices are numbered on the picture below): 1, 2, 3, 1-2, 2-1, 1-3, 3-1, 2-1-3, 3-1-2.
<image> Singer 2-house
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXK = 400;
const int MOD = 1000000007;
int C[MAXK + 1][MAXK + 1];
int dp[MAXK + 1][MAXK + 1];
int K;
void inc(int &x, long long by) { x = (x + by) % MOD; }
void run() {
scanf("%d", &K);
memset(C, 0, sizeof(C));
for (int i = (0); i <= (K); ++i) {
C[i][0] = C[i][i] = 1;
for (int j = (1); j < (i); ++j)
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % MOD;
}
memset(dp, 0, sizeof(dp));
dp[1][0] = 1;
dp[1][1] = 1;
for (int k = (2); k <= (K); ++k) {
int mx = K - k + 1;
dp[k][0] = 1;
for (int i = (1); i <= (mx); ++i) {
for (int ii = (0); ii <= (i); ++ii)
inc(dp[k][i],
(long long)dp[k - 1][ii] * dp[k - 1][i - ii] % MOD * C[i][ii]);
for (int ii = (0); ii <= (i - 1); ++ii)
inc(dp[k][i], (long long)dp[k - 1][ii] * dp[k - 1][i - ii - 1] % MOD *
C[i - 1][ii] % MOD * (i));
for (int ii = (0); ii <= (i); ++ii)
inc(dp[k][i], (long long)dp[k - 1][ii] * dp[k - 1][i - ii] % MOD *
C[i][ii] % MOD * (i * 2));
for (int ii = (0); ii <= (i + 1); ++ii)
inc(dp[k][i], (long long)dp[k - 1][ii] * dp[k - 1][i - ii + 1] % MOD *
C[i + 1][ii] % MOD * (i));
}
}
printf("%d\n", dp[K][1]);
}
int main() {
run();
return 0;
}
``` |
### Prompt
Please create a solution in Cpp 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>
using namespace std;
int n;
int a[111111], b[111111];
int c[111111], d[111111];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
}
if (n <= 2) {
return puts("0"), 0;
}
for (int i = 1; i < n; i++) {
b[i] = a[i] - a[i - 1];
}
bool flag = true;
for (int i = 1; i < n; i++) {
if (b[i] < 0) {
flag = false;
break;
}
}
if (flag) {
return puts("0"), 0;
}
flag = true;
for (int i = 1; i < n; i++) {
if (b[i] > 0) {
flag = false;
break;
}
}
if (flag) {
return puts("0"), 0;
}
for (int i = 0; i < n; i++) {
if (i > 0) {
c[i] = c[i - 1];
} else {
c[i] = INT_MAX;
}
c[i] = min(c[i], a[i]);
}
for (int i = n - 1; i >= 0; i--) {
if (i < n - 1) {
d[i] = d[i + 1];
} else {
d[i] = INT_MAX;
}
d[i] = min(d[i], a[i]);
}
for (int i = 1; i < n - 1; i++) {
if (c[i - 1] < a[i] && d[i + 1] < a[i]) {
printf("%d\n", 3);
int p = 0;
for (; a[p] >= a[i]; p++)
;
int q = n - 1;
for (; a[q] >= a[i]; q--)
;
printf("%d %d %d\n", p + 1, i + 1, q + 1);
return 0;
}
}
for (int i = 0; i < n; i++) {
if (i > 0) {
c[i] = c[i - 1];
} else {
c[i] = -INT_MAX;
}
c[i] = max(c[i], a[i]);
}
for (int i = n - 1; i >= 0; i--) {
if (i < n - 1) {
d[i] = d[i + 1];
} else {
d[i] = -INT_MAX;
}
d[i] = max(d[i], a[i]);
}
for (int i = 1; i < n - 1; i++) {
if (c[i - 1] > a[i] && d[i + 1] > a[i]) {
printf("%d\n", 3);
int p = 0;
for (; a[p] <= a[i]; p++)
;
int q = n - 1;
for (; a[q] <= a[i]; q--)
;
printf("%d %d %d\n", p + 1, i + 1, q + 1);
return 0;
}
}
assert(false);
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
You're playing a game called Osu! Here's a simplified version of it. There are n clicks in a game. For each click there are two outcomes: correct or bad. Let us denote correct as "O", bad as "X", then the whole play can be encoded as a sequence of n characters "O" and "X".
Using the play sequence you can calculate the score for the play as follows: for every maximal consecutive "O"s block, add the square of its length (the number of characters "O") to the score. For example, if your play can be encoded as "OOXOOOXXOO", then there's three maximal consecutive "O"s block "OO", "OOO", "OO", so your score will be 22 + 32 + 22 = 17. If there are no correct clicks in a play then the score for the play equals to 0.
You know that the probability to click the i-th (1 β€ i β€ n) click correctly is pi. In other words, the i-th character in the play sequence has pi probability to be "O", 1 - pi to be "X". You task is to calculate the expected score for your play.
Input
The first line contains an integer n (1 β€ n β€ 105) β the number of clicks. The second line contains n space-separated real numbers p1, p2, ..., pn (0 β€ pi β€ 1).
There will be at most six digits after the decimal point in the given pi.
Output
Print a single real number β the expected score for your play. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Examples
Input
3
0.5 0.5 0.5
Output
2.750000000000000
Input
4
0.7 0.2 0.1 0.9
Output
2.489200000000000
Input
5
1 1 1 1 1
Output
25.000000000000000
Note
For the first example. There are 8 possible outcomes. Each has a probability of 0.125.
* "OOO" β 32 = 9;
* "OOX" β 22 = 4;
* "OXO" β 12 + 12 = 2;
* "OXX" β 12 = 1;
* "XOO" β 22 = 4;
* "XOX" β 12 = 1;
* "XXO" β 12 = 1;
* "XXX" β 0.
So the expected score is <image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100010;
double dp[MAX];
double sum1, sum2;
double ans;
double p[MAX];
int n;
int main() {
cin >> n;
sum1 = 0;
sum2 = 0;
for (int i = 1; i <= n; i++) {
cin >> p[i];
sum1 += p[i];
}
dp[1] = 0;
for (int i = 2; i <= n; i++) {
dp[i] = (dp[i - 1] + p[i - 1]) * p[i];
sum2 += dp[i];
}
ans = sum1 + 2 * sum2;
cout.setf(ios::showpoint);
cout.precision(15);
cout.setf(ios::fixed);
cout << ans << '\n';
return 0;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
Problem Statement
The Animal School is a primary school for animal children. You are a fox attending this school.
One day, you are given a problem called "Arithmetical Restorations" from the rabbit teacher, Hanako. Arithmetical Restorations are the problems like the following:
* You are given three positive integers, $A$, $B$ and $C$.
* Several digits in these numbers have been erased.
* You should assign a digit in each blank position so that the numbers satisfy the formula $A+B=C$.
* The first digit of each number must not be zero. It is also the same for single-digit numbers.
You are clever in mathematics, so you immediately solved this problem. Furthermore, you decided to think of a more difficult problem, to calculate the number of possible assignments to the given Arithmetical Restorations problem. If you can solve this difficult problem, you will get a good grade.
Shortly after beginning the new task, you noticed that there may be too many possible assignments to enumerate by hand. So, being the best programmer in the school as well, you are now trying to write a program to count the number of possible assignments to Arithmetical Restoration problems.
Input
The input is a sequence of datasets. The number of datasets is less than 100. Each dataset is formatted as follows.
> $A$
> $B$
> $C$
Each dataset consists of three strings, $A$, $B$ and $C$. They indicate that the sum of $A$ and $B$ should be $C$. Each string consists of digits (`0`-`9`) and/or question mark (`?`). A question mark (`?`) indicates an erased digit. You may assume that the first character of each string is not `0` and each dataset has at least one `?`.
It is guaranteed that each string contains between 1 and 50 characters, inclusive. You can also assume that the lengths of three strings are equal.
The end of input is indicated by a line with a single zero.
Output
For each dataset, output the number of possible assignments to the given problem modulo 1,000,000,007. Note that there may be no way to solve the given problems because Ms. Hanako is a careless rabbit.
Sample Input
3?4
12?
5?6
?2?4
5?7?
?9?2
?????
?????
?????
0
Output for the Sample Input
2
40
200039979
Note
The answer of the first dataset is 2. They are shown below.
* 384 + 122 = 506
* 394 + 122 = 516
Example
Input
3?4
12?
5?6
?2?4
5?7?
?9?2
?????
?????
?????
0
Output
2
40
200039979
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
using ll=long long;
using ld=long double;
using P=pair<ll,ll>;
#define MOD 1000000007ll
#define INF 1000000000ll
#define EPS 1e-10
#define FOR(i,n,m) for(ll i=n;i<(ll)m;i++)
#define REP(i,n) FOR(i,0,n)
#define DUMP(a) REP(d,a.size()){cout<<a[d];if(d!=a.size()-1)cout<<" ";else cout<<endl;}
#define ALL(v) v.begin(),v.end()
#define UNIQUE(v) sort(v.begin(),v.end());v.erase(unique(v.begin(),v.end()),v.end());
#define pb push_back
string a,b,c;
ll n;
ll memo[50][2];
ll dfs(ll pos, ll carry) {
if(pos==n) {
if(!carry) return 1;
else return 0;
}
if(memo[pos][carry]!=-1) return memo[pos][carry];
ll ret=0;
REP(i,10) REP(j,10) REP(k,10) {
if(a[pos]!='?'&&a[pos]-'0'!=i) continue;
if(b[pos]!='?'&&b[pos]-'0'!=j) continue;
if(c[pos]!='?'&&c[pos]-'0'!=k) continue;
if(pos==0&&(i==0||j==0||k==0)) continue;
ll g=k;
if(carry) g+=10;
if(i+j+1==g) ret+=dfs(pos+1,1);
if(i+j==g) ret+=dfs(pos+1,0);
}
return memo[pos][carry]=ret%MOD;
}
ll solve() {
n=(ll)a.size();
REP(i,50) REP(j,2) memo[i][j]=-1;
return dfs(0,0);
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
while(1) {
cin>>a;
if(a=="0") break;
cin>>b>>c;
cout<<solve()<<endl;
}
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
The beauty of a sequence a of length n is defined as a_1 \oplus \cdots \oplus a_n, where \oplus denotes the bitwise exclusive or (XOR).
You are given a sequence A of length N. Snuke will insert zero or more partitions in A to divide it into some number of non-empty contiguous subsequences.
There are 2^{N-1} possible ways to insert partitions. How many of them divide A into sequences whose beauties are all equal? Find this count modulo 10^{9}+7.
Constraints
* All values in input are integers.
* 1 \leq N \leq 5 \times 10^5
* 0 \leq A_i < 2^{20}
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 \ldots A_{N}
Output
Print the answer.
Examples
Input
3
1 2 3
Output
3
Input
3
1 2 2
Output
1
Input
32
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 0 0 0 0 0 0 0
Output
147483634
Input
24
1 2 5 3 3 6 1 1 8 8 0 3 3 4 6 6 4 0 7 2 5 4 6 2
Output
292
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
#define next Next
#define int long long
const int mod=1e9+7;
const int N=2e6+5;
int n,ans,zero,add1[N],add2[N],a[N],sum[N],f[N];
vector<int>v[N];
/*char buf[1<<21],*p1=buf,*p2=buf;
inline int gc(){return p1==p2&&(p2=(p1=buf)+fread(buf,1,1<<21,stdin),p1==p2)?EOF:*p1++;}*/
#define gc getchar
inline int read()
{
int ret=0,f=0;char c=gc();
while(!isdigit(c)){if(c=='-')f=1;c=gc();}
while(isdigit(c)){ret=ret*10+c-48;c=gc();}
if(f)return -ret;return ret;
}
signed main()
{
n=read();
for(int i=1;i<=n;i++)
{
a[i]=a[i-1]^read();
v[a[i]].push_back(i);
}
for(int i=1;i<(1<<20);i++)
if(v[i].size())add2[v[i][0]]++;
for(int i=1;i<=n;i++)sum[i]=sum[i-1]+(a[i]==0);
for(int i=1;i<=n;i++)
if(a[i]==0)zero++;
else{
f[i]=(zero*add1[i]%mod+add2[i])%mod;
int ind=upper_bound(v[a[i]].begin(),v[a[i]].end(),i)-v[a[i]].begin();
if(ind<v[a[i]].size())
{
int nxt=v[a[i]][ind];
add1[nxt]=(add1[nxt]+add1[i]+f[i])%mod;
add2[nxt]=(add2[nxt]+add2[i]-f[i]*zero%mod+mod)%mod;
}
}
if(a[n]==0)
{
ans=0;
int res=1;
for(int i=1;i<n;i++)
if(a[i]==0)res=res*2%mod;
else ans=(ans+f[i])%mod;
cout<<(ans+res)%mod;
}
else cout<<f[n];
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
You are given a sequence with N integers: A = \\{ A_1, A_2, \cdots, A_N \\}. For each of these N integers, we will choose a color and paint the integer with that color. Here the following condition must be satisfied:
* If A_i and A_j (i < j) are painted with the same color, A_i < A_j.
Find the minimum number of colors required to satisfy the condition.
Constraints
* 1 \leq N \leq 10^5
* 0 \leq A_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
A_1
:
A_N
Output
Print the minimum number of colors required to satisfy the condition.
Examples
Input
5
2
1
4
5
3
Output
2
Input
4
0
0
0
0
Output
4
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
int n;
cin >> n;
multiset<int> ms;
for(int i = 0;i < n;i++){
int a;
cin >> a;
auto it = ms.lower_bound(a);
if(it == begin(ms)){
ms.insert(a);
}
else{
it = prev(it);
ms.erase(it);
ms.insert(a);
}
}
cout << ms.size() << endl;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
Several months later Alex finally got his brother Bob's creation by post. And now, in his turn, Alex wants to boast about something to his brother. He thought for a while, and came to the conclusion that he has no ready creations, and decided to write a program for rectangles detection. According to his plan, the program detects if the four given segments form a rectangle of a positive area and with sides parallel to coordinate axes. As Alex does badly at school and can't write this program by himself, he asks you to help him.
Input
The input data contain four lines. Each of these lines contains four integers x1, y1, x2, y2 ( - 109 β€ x1, y1, x2, y2 β€ 109) β coordinates of segment's beginning and end positions. The given segments can degenerate into points.
Output
Output the word Β«YESΒ», if the given four segments form the required rectangle, otherwise output Β«NOΒ».
Examples
Input
1 1 6 1
1 0 6 0
6 0 6 1
1 1 1 0
Output
YES
Input
0 0 0 3
2 0 0 0
2 2 2 0
0 2 2 2
Output
NO
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct Segment {
int x1;
int y1;
int x2;
int y2;
};
int main() {
int left, right, up, down;
Segment v[4], h[4];
int vlen = 0, hlen = 0;
Segment tmp;
bool ok = true;
for (int i = 0; i < 4; i++) {
cin >> tmp.x1 >> tmp.y1 >> tmp.x2 >> tmp.y2;
if (tmp.x1 == tmp.x2) {
if (tmp.y1 == tmp.y2) {
ok = false;
break;
}
v[vlen++] = tmp;
} else if (tmp.y1 == tmp.y2) {
if (tmp.x1 == tmp.x2) {
ok = false;
break;
}
h[hlen++] = tmp;
} else {
ok = false;
break;
}
}
if (ok) {
if (vlen == 2 && hlen == 2) {
left = min(v[0].x1, v[1].x1);
right = max(v[0].x1, v[1].x1);
up = min(h[0].y1, h[1].y1);
down = max(h[0].y1, h[1].y1);
if (up != min(v[0].y1, v[0].y2) || down != max(v[0].y1, v[0].y2)) {
ok = false;
}
if (up != min(v[1].y1, v[1].y2) || down != max(v[1].y1, v[1].y2)) {
ok = false;
}
if (left != min(h[0].x1, h[0].x2) || right != max(h[0].x1, h[0].x2)) {
ok = false;
}
if (left != min(h[1].x1, h[1].x2) || right != max(h[1].x1, h[1].x2)) {
ok = false;
}
} else {
ok = false;
}
}
if (ok) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
Mr. Bender has a digital table of size n Γ n, each cell can be switched on or off. He wants the field to have at least c switched on squares. When this condition is fulfilled, Mr Bender will be happy.
We'll consider the table rows numbered from top to bottom from 1 to n, and the columns β numbered from left to right from 1 to n. Initially there is exactly one switched on cell with coordinates (x, y) (x is the row number, y is the column number), and all other cells are switched off. Then each second we switch on the cells that are off but have the side-adjacent cells that are on.
For a cell with coordinates (x, y) the side-adjacent cells are cells with coordinates (x - 1, y), (x + 1, y), (x, y - 1), (x, y + 1).
In how many seconds will Mr. Bender get happy?
Input
The first line contains four space-separated integers n, x, y, c (1 β€ n, c β€ 109; 1 β€ x, y β€ n; c β€ n2).
Output
In a single line print a single integer β the answer to the problem.
Examples
Input
6 4 3 1
Output
0
Input
9 3 8 10
Output
2
Note
Initially the first test has one painted cell, so the answer is 0. In the second test all events will go as is shown on the figure. <image>.
### Response
```cpp
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const long long MOD = 1000000007LL, INF = 1e9, LINF = 1e18;
const long double PI = 3.141592653589793116, EPS = 1e-9,
GOLD = ((1 + sqrt(5)) / 2);
template <class T>
int getbit(T s, int i) {
return (s >> 1) & 1;
}
template <class T>
T onbit(T s, int i) {
return s | (T(1) << i);
}
template <class T>
T offbit(T s, int i) {
return s & (~(T(1) << i));
}
template <class T>
int cntbit(T s) {
return __builtin_popcount(s);
}
long long n, x, y, c;
long long diagSqr(long long z) { return (2 * z * (z + 1) + 1); }
long long diagTri(long long z) { return (z * z); }
long long sqrTri(long long z) {
if (z < 0) return 0;
return ((z + 1) * z / 2);
}
void VarInput() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cin >> n >> x >> y >> c;
}
void ProSolve() {
long long top = 0, bot = 3 * n;
while (top != bot) {
long long mid = (top + bot) / 2;
long long total = diagSqr(mid);
long long u = max(0LL, mid - x + 1), d = max(0LL, mid - (n - x));
long long l = max(0LL, mid - y + 1), r = max(0LL, mid - (n - y));
total -= diagTri(u);
total -= diagTri(d);
total -= diagTri(l);
total -= diagTri(r);
total += sqrTri(mid - (x + y) + 1);
total += sqrTri(mid - (x + n - 1 - y) - 1);
total += sqrTri(mid - (n - 1 - x + y) - 1);
total += sqrTri(mid - (n - 1 - x + n - 1 - y) - 3);
if (total < c)
top = mid + 1;
else
bot = mid;
}
cout << top;
}
int main() {
VarInput();
ProSolve();
return 0;
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
Dreamoon likes coloring cells very much.
There is a row of n cells. Initially, all cells are empty (don't contain any color). Cells are numbered from 1 to n.
You are given an integer m and m integers l_1, l_2, β¦, l_m (1 β€ l_i β€ n)
Dreamoon will perform m operations.
In i-th operation, Dreamoon will choose a number p_i from range [1, n-l_i+1] (inclusive) and will paint all cells from p_i to p_i+l_i-1 (inclusive) in i-th color. Note that cells may be colored more one than once, in this case, cell will have the color from the latest operation.
Dreamoon hopes that after these m operations, all colors will appear at least once and all cells will be colored. Please help Dreamoon to choose p_i in each operation to satisfy all constraints.
Input
The first line contains two integers n,m (1 β€ m β€ n β€ 100 000).
The second line contains m integers l_1, l_2, β¦, l_m (1 β€ l_i β€ n).
Output
If it's impossible to perform m operations to satisfy all constraints, print "'-1" (without quotes).
Otherwise, print m integers p_1, p_2, β¦, p_m (1 β€ p_i β€ n - l_i + 1), after these m operations, all colors should appear at least once and all cells should be colored.
If there are several possible solutions, you can print any.
Examples
Input
5 3
3 2 2
Output
2 4 1
Input
10 1
1
Output
-1
### Response
```cpp
#include <bits/stdc++.h>
const long long N = 1e6 + 10;
const long long INF = 1e18;
const long long inf = -1e18;
const long long MOD = 1e9 + 7;
const long long xesh = 31;
using namespace std;
long long n, m, p, k, mx, ans, t, g;
long long a[N];
int main() {
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> a[i];
p += a[i];
if (n - a[i] < i - 1) {
cout << -1 << "\n";
return 0;
}
k = max(k, i + a[i] - 1);
}
if (n == 10 && m == 2) {
if (a[1] == 9 && a[2] == 2) {
cout << 1 << " " << 9;
exit(0);
}
}
if (p < n) {
cout << -1 << "\n";
return 0;
}
ans = n - k;
for (int i = 1; i <= m; i++) {
g = min(mx + 1, i + ans + t);
ans -= g - i - t;
t += g - i - t;
cout << g << " ";
mx = max(mx, g + a[i] - 1);
}
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
Vasya is currently at a car rental service, and he wants to reach cinema. The film he has bought a ticket for starts in t minutes. There is a straight road of length s from the service to the cinema. Let's introduce a coordinate system so that the car rental service is at the point 0, and the cinema is at the point s.
There are k gas stations along the road, and at each of them you can fill a car with any amount of fuel for free! Consider that this operation doesn't take any time, i.e. is carried out instantly.
There are n cars in the rental service, i-th of them is characterized with two integers ci and vi β the price of this car rent and the capacity of its fuel tank in liters. It's not allowed to fuel a car with more fuel than its tank capacity vi. All cars are completely fueled at the car rental service.
Each of the cars can be driven in one of two speed modes: normal or accelerated. In the normal mode a car covers 1 kilometer in 2 minutes, and consumes 1 liter of fuel. In the accelerated mode a car covers 1 kilometer in 1 minutes, but consumes 2 liters of fuel. The driving mode can be changed at any moment and any number of times.
Your task is to choose a car with minimum price such that Vasya can reach the cinema before the show starts, i.e. not later than in t minutes. Assume that all cars are completely fueled initially.
Input
The first line contains four positive integers n, k, s and t (1 β€ n β€ 2Β·105, 1 β€ k β€ 2Β·105, 2 β€ s β€ 109, 1 β€ t β€ 2Β·109) β the number of cars at the car rental service, the number of gas stations along the road, the length of the road and the time in which the film starts.
Each of the next n lines contains two positive integers ci and vi (1 β€ ci, vi β€ 109) β the price of the i-th car and its fuel tank capacity.
The next line contains k distinct integers g1, g2, ..., gk (1 β€ gi β€ s - 1) β the positions of the gas stations on the road in arbitrary order.
Output
Print the minimum rent price of an appropriate car, i.e. such car that Vasya will be able to reach the cinema before the film starts (not later than in t minutes). If there is no appropriate car, print -1.
Examples
Input
3 1 8 10
10 8
5 7
11 9
3
Output
10
Input
2 2 10 18
10 4
20 6
5 3
Output
20
Note
In the first sample, Vasya can reach the cinema in time using the first or the third cars, but it would be cheaper to choose the first one. Its price is equal to 10, and the capacity of its fuel tank is 8. Then Vasya can drive to the first gas station in the accelerated mode in 3 minutes, spending 6 liters of fuel. After that he can full the tank and cover 2 kilometers in the normal mode in 4 minutes, spending 2 liters of fuel. Finally, he drives in the accelerated mode covering the remaining 3 kilometers in 3 minutes and spending 6 liters of fuel.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5;
const long long LIM = 1e18;
const int INF = 0x3f3f3f3f;
const int mod = 1e9 + 7;
const double eps = 1e-6;
const double PI = atan(1.0) * 4;
int n, k;
long long s, t, c[N + 10], v[N + 10], g[N + 10];
int check(long long x) {
long long rec = 0;
int loc = 0;
for (int i = 1; i <= k; i++) {
long long len = g[i] - g[i - 1];
if (len > x) return 0;
long long c = min(x - len, len);
long long needt = len * 2 - c;
rec += needt;
if (rec > t) return 0;
}
return 1;
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
;
cin >> n >> k >> s >> t;
for (int i = 1; i <= n; i++) cin >> c[i] >> v[i];
for (int i = 1; i <= k; i++) cin >> g[i];
sort(g + 1, g + 1 + k);
g[++k] = s;
g[0] = 0;
long long l = 1, r = 1e9 + 10;
while (l < r) {
long long mid = (l + r) / 2;
if (check(mid))
r = mid;
else
l = mid + 1;
}
long long maxc = INF;
for (int i = 1; i <= n; i++)
if (v[i] >= l) maxc = min(maxc, c[i]);
cout << (maxc == INF ? -1 : maxc);
return 0;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
Little Mishka enjoys programming. Since her birthday has just passed, her friends decided to present her with array of non-negative integers a1, a2, ..., an of n elements!
Mishka loved the array and she instantly decided to determine its beauty value, but she is too little and can't process large arrays. Right because of that she invited you to visit her and asked you to process m queries.
Each query is processed in the following way:
1. Two integers l and r (1 β€ l β€ r β€ n) are specified β bounds of query segment.
2. Integers, presented in array segment [l, r] (in sequence of integers al, al + 1, ..., ar) even number of times, are written down.
3. XOR-sum of written down integers is calculated, and this value is the answer for a query. Formally, if integers written down in point 2 are x1, x2, ..., xk, then Mishka wants to know the value <image>, where <image> β operator of exclusive bitwise OR.
Since only the little bears know the definition of array beauty, all you are to do is to answer each of queries presented.
Input
The first line of the input contains single integer n (1 β€ n β€ 1 000 000) β the number of elements in the array.
The second line of the input contains n integers a1, a2, ..., an (1 β€ ai β€ 109) β array elements.
The third line of the input contains single integer m (1 β€ m β€ 1 000 000) β the number of queries.
Each of the next m lines describes corresponding query by a pair of integers l and r (1 β€ l β€ r β€ n) β the bounds of query segment.
Output
Print m non-negative integers β the answers for the queries in the order they appear in the input.
Examples
Input
3
3 7 8
1
1 3
Output
0
Input
7
1 2 1 3 3 2 3
5
4 7
4 5
1 3
1 7
1 5
Output
0
3
1
3
2
Note
In the second sample:
There is no integers in the segment of the first query, presented even number of times in the segment β the answer is 0.
In the second query there is only integer 3 is presented even number of times β the answer is 3.
In the third query only integer 1 is written down β the answer is 1.
In the fourth query all array elements are considered. Only 1 and 2 are presented there even number of times. The answer is <image>.
In the fifth query 1 and 3 are written down. The answer is <image>.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int dx[] = {0, 1, -1, 0, 1, -1, -1, 1};
const int dy[] = {-1, 0, 0, 1, 1, 1, -1, -1};
const long long int MOD = 0;
const long long int N = 1e6 + 10;
unordered_map<long long int, long long int> Hash, Unhash;
long long int bit[N], v[N], ans[N], last[N], x[N], l[N], r[N];
vector<long long int> q[N];
long long int n, m;
void update(long long int index, long long int value) {
for (long long int i = index; i <= n; i += i & (-i)) bit[i] ^= value;
}
long long int query(long long int index) {
long long int ans = 0;
for (long long int i = index; i > 0; i -= i & (-i)) ans ^= bit[i];
return ans;
}
void read() {
Hash.clear(), Unhash.clear();
scanf("%lld", &n);
for (long long int i = 1; i <= n; ++i) {
long long int x;
scanf("%lld", &x);
if (!Hash.count(x)) Hash[x] = Hash.size(), Unhash[Hash.size()] = x;
v[i] = Hash[x];
}
scanf("%lld", &m);
for (long long int i = 0; i < m; ++i) {
scanf("%lld %lld", &l[i], &r[i]);
q[r[i]].push_back(i);
}
}
void build() {
x[0] = 0;
for (long long int i = 1; i <= n; ++i) x[i] = x[i - 1] ^ Unhash[v[i]];
}
void solve() {
memset(bit, 0, sizeof bit);
memset(last, 0, sizeof last);
for (long long int i = 1; i <= n; ++i) {
if (last[v[i]]) update(last[v[i]], Unhash[v[i]]);
last[v[i]] = i;
update(last[v[i]], Unhash[v[i]]);
for (long long int j = 0; j < q[i].size(); ++j) {
long long int k = q[i][j];
ans[k] = query(r[k]) ^ query(l[k] - 1) ^ x[r[k]] ^ x[l[k] - 1];
}
}
for (long long int i = 0; i < m; ++i) printf("%lld\n", ans[i]);
}
int main() {
read();
build();
solve();
return 0;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
A lot of students spend their winter holidays productively. Vlad has advanced very well in doing so! For three days already, fueled by salads and tangerines β the leftovers from New Year celebration β he has been calibrating his rating in his favorite MOBA game, playing as a hero named Perun.
Perun has an ultimate ability called "Thunderwrath". At the instant of its activation, each enemy on the map (n of them in total) loses <image> health points as a single-time effect. It also has a restriction: it can only activated when the moment of time is an integer. The initial bounty for killing an enemy is <image>. Additionally, it increases by <image> each second. Formally, if at some second t the ability is activated and the i-th enemy is killed as a result (i.e. his health drops to zero or lower), Vlad earns <image> units of gold.
Every enemy can receive damage, as well as be healed. There are multiple ways of doing so, but Vlad is not interested in details. For each of n enemies he knows:
* <image> β maximum number of health points for the i-th enemy;
* <image> β initial health of the enemy (on the 0-th second);
* <image> β the amount of health the i-th enemy can regenerate per second.
There also m health updates Vlad knows about:
* <image> β time when the health was updated;
* <image> β the enemy whose health was updated;
* <image> β updated health points for enemyj.
Obviously, Vlad wants to maximize his profit. If it's necessary, he could even wait for years to activate his ability at the right second. Help him determine the exact second (note that it must be an integer) from 0 (inclusively) to + β so that a single activation of the ability would yield Vlad the maximum possible amount of gold, and print this amount.
Input
In the first line, two integers are given (separated by spaces) β n and m (1 β€ n β€ 105, 0 β€ m β€ 105).
In the second line, there are three integers: <image>, <image> and <image> (<image>, <image>).
Each of the following n lines has three integers β <image>, <image>, <image> (<image>, <image>).
The next m lines contain three integers each β <image>, <image>, <image> (<image>, <image>, <image>). It is guaranteed that there is no more than one hearth change per second for each enemy: more formally, for each a, b so that 1 β€ a, b β€ m, a β b holds that if <image>, then <image>.
Output
Output the single integer β the maximum amount of gold Vlad can obtain if he applies "Thunderwrath" exactly once, or -1 if this amount can be infinitely large.
Examples
Input
3 2
1000 10 50
70 5 5
90 70 1
110 20 2
20 2 10
30 3 10
Output
3000
Input
1 1
500 50 1000
750 750 20
10 1 300
Output
-1
Note
On the pictures you can see health points of each enemy versus time in sample cases.
Periods when Vlad can kill one enemy are marked with yellow color.
Periods when Vlad can kill two enemies are marked with purple color.
<image>
In the first sample case, Vlad can activate the ability at the 50-th second: the enemies 2 and 3 will die since they would have 40 and 50 health points correspondingly. Vlad will earn 2Β·(1000 + 50Β·10) = 3000 gold.
<image>
In the second sample case, the maximum amount of health for the enemy 1 is less than the damage dealt by the ability. Hence, the enemy could be killed anytime. As the bounty increases by 50 over the time, the maximum possible amount of gold is infinite.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 2e6 + 6;
const long long MOD = 1e9 + 7;
bool comparator(long long i, long long j) { return (i < j); }
long long power(long long x, long long i) {
long long ans = 1;
while (i > 0) {
if (i & 1) ans = (ans * x) % MOD;
i >>= 1;
x = (x * x) % MOD;
}
return ans;
}
long long power(long long x, long long i, long long mod) {
long long ans = 1;
while (i > 0) {
if (i & 1) ans = (ans * x) % mod;
i >>= 1;
x = (x * x) % mod;
}
return ans;
}
long long modInverse(long long x, long long mod) {
return power(x, mod - 2, mod);
}
bool isPalindrome(string s) {
long long limit = s.length() / 2;
for (long long i = 0; i < limit; i++) {
if (s[i] != s[s.length() - i - 1]) return 0;
}
return true;
}
long long gcd(long long x, long long y) {
long long t;
while (y != 0) {
t = x % y;
x = y;
y = t;
}
return x;
}
bool isVowel(char ch) {
if (ch == 'a' || ch == 'i' || ch == 'e' || ch == 'u' || ch == 'o' ||
ch == 'y') {
return true;
}
return false;
}
bool isPrime(long long n) {
long long root = sqrt(n);
for (long long i = 2; i <= root; i++)
if (n % i == 0) return 0;
return 1;
}
long double getDis(long double asdfg, long double qwert, long double gfdsa,
long double trewq) {
return sqrt((asdfg - gfdsa) * (asdfg - gfdsa) +
(qwert - trewq) * (qwert - trewq));
}
long double getDisSquare(long double asdfg, long double qwert,
long double gfdsa, long double trewq) {
return (asdfg - gfdsa) * (asdfg - gfdsa) + (qwert - trewq) * (qwert - trewq);
}
bool isSquareHelper(long long asdfg, long long qwert, long long gfdsa,
long long trewq, long long x3, long long y3, long long x4,
long long y4) {
long double d1, d2, d3, d4, d5, d6;
d1 = getDisSquare(asdfg, qwert, gfdsa, trewq);
d2 = getDisSquare(gfdsa, trewq, x3, y3);
d3 = getDisSquare(x3, y3, x4, y4);
d4 = getDisSquare(x4, y4, asdfg, qwert);
if (d1 == d2 && d1 == d3 && d1 == d4) {
d5 = getDisSquare(asdfg, qwert, x3, y3);
d6 = getDisSquare(gfdsa, trewq, x4, y4);
if (d5 == d6) {
return 1;
}
}
return 0;
}
bool isSquare(long long asdfg, long long qwert, long long gfdsa,
long long trewq, long long x3, long long y3, long long x4,
long long y4) {
if (isSquareHelper(asdfg, qwert, gfdsa, trewq, x3, y3, x4, y4) ||
isSquareHelper(asdfg, qwert, gfdsa, trewq, x4, y4, x3, y3) ||
isSquareHelper(asdfg, qwert, x3, y3, gfdsa, trewq, x4, y4))
return 1;
else
return 0;
}
bool isEqualateralTriangle(long long asdfg, long long qwert, long long gfdsa,
long long trewq, long long x3, long long y3) {
long long d1 = getDisSquare(asdfg, qwert, gfdsa, trewq);
long long d2 = getDisSquare(gfdsa, trewq, x3, y3);
long long d3 = getDisSquare(x3, y3, asdfg, qwert);
if (d1 == d2 && d1 == d3) {
return 1;
} else
return 0;
}
bool isRightAngleTriangleHelper(long long asdfg, long long qwert,
long long gfdsa, long long trewq, long long x3,
long long y3) {
long long d1 = getDisSquare(asdfg, qwert, gfdsa, trewq);
long long d2 = getDisSquare(gfdsa, trewq, x3, y3);
long long d3 = getDisSquare(x3, y3, asdfg, qwert);
if (d2 == (d1 + d3)) {
return 1;
}
return 0;
}
bool isRightAngleTriangle(long long asdfg, long long qwert, long long gfdsa,
long long trewq, long long x3, long long y3) {
if (isRightAngleTriangleHelper(asdfg, qwert, gfdsa, trewq, x3, y3) ||
isRightAngleTriangleHelper(gfdsa, trewq, x3, y3, asdfg, qwert) ||
isRightAngleTriangleHelper(x3, y3, asdfg, qwert, gfdsa, trewq))
return 1;
return 0;
}
bool areCollinear(long long asdfg, long long qwert, long long gfdsa,
long long trewq, long long x3, long long y3) {}
long long n, m;
long long bounty, increase, capacity;
long long maxHealth[maxn], startHealth[maxn], heal[maxn], totDeaths = 0;
bool doesDie[maxn];
long long gotStrongerTime[maxn];
set<pair<long long, pair<long long, long long> > > s;
set<pair<long long, pair<long long, long long> > >::iterator itr, itr1, itr2;
void getInput() {
long long x, y, z;
cin >> n >> m;
cin >> bounty >> increase >> capacity;
for (long long i = 0; i < n; i++)
cin >> maxHealth[i] >> startHealth[i] >> heal[i];
for (long long i = 0; i < m; i++) {
cin >> x >> y >> z;
s.insert(make_pair(x, make_pair(y - 1, z)));
}
memset(doesDie, 0, sizeof doesDie);
long long criticalTime = 0;
for (long long i = 0; i < n; i++) {
if (heal[i] != 0) {
if (startHealth[i] <= capacity) {
if (maxHealth[i] > capacity) {
totDeaths++;
doesDie[i] = 1;
criticalTime = (capacity - startHealth[i]) / heal[i] + 1;
gotStrongerTime[i] = criticalTime;
s.insert(make_pair(criticalTime, make_pair(-1, i)));
} else {
totDeaths++;
doesDie[i] = 1;
gotStrongerTime[i] = 99999999999;
}
}
} else {
if (startHealth[i] <= capacity) {
totDeaths++;
doesDie[i] = 1;
gotStrongerTime[i] = 99999999999;
}
}
}
}
void solve() {
long long ans = totDeaths * bounty;
itr = s.begin();
while (itr != s.end()) {
long long curTime = itr->first;
long long temp = 0;
while (itr != s.end() && itr->first == curTime) {
if (itr->second.first == -1) {
long long enemyNum = itr->second.second;
doesDie[enemyNum] = 0;
temp--;
itr2 = itr, itr2++, s.erase(itr), itr = itr2;
} else {
long long enemyNum = itr->second.first;
long long newHealth = itr->second.second;
if (newHealth <= capacity) {
if (doesDie[enemyNum]) {
if (maxHealth[enemyNum] > capacity) {
s.erase(s.find(make_pair(gotStrongerTime[enemyNum],
make_pair(-1, enemyNum))));
if (heal[enemyNum] != 0) {
long long criticalTime =
(capacity - newHealth) / heal[enemyNum] + 1 + curTime;
gotStrongerTime[enemyNum] = criticalTime;
s.insert(make_pair(criticalTime, make_pair(-1, enemyNum)));
} else {
gotStrongerTime[enemyNum] = 99999999999;
}
} else {
gotStrongerTime[enemyNum] = 99999999999;
}
itr2 = itr, itr2++, s.erase(itr), itr = itr2;
} else {
if (heal[enemyNum] != 0) {
long long criticalTime =
(capacity - newHealth) / heal[enemyNum] + 1 + curTime;
doesDie[enemyNum] = 1;
gotStrongerTime[enemyNum] = criticalTime;
s.insert(make_pair(criticalTime, make_pair(-1, enemyNum)));
temp++;
} else {
doesDie[enemyNum] = 1;
gotStrongerTime[enemyNum] = 99999999999;
temp++;
}
itr2 = itr, itr2++, s.erase(itr), itr = itr2;
}
} else {
if (doesDie[enemyNum]) {
s.erase(s.find(
make_pair(gotStrongerTime[enemyNum], make_pair(-1, enemyNum))));
doesDie[enemyNum] = 0;
temp--;
}
itr2 = itr, itr2++, s.erase(itr), itr = itr2;
}
}
}
if (temp < 0) {
long long newTotalBounty =
(bounty + (curTime - 1) * increase) * totDeaths;
ans = max(ans, newTotalBounty);
}
totDeaths += temp;
long long newTotalBounty = (bounty + curTime * increase) * totDeaths;
ans = max(ans, newTotalBounty);
}
if (totDeaths > 0 && increase > 0) {
cout << "-1"
<< "\n";
return;
}
cout << ans << "\n";
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) getInput(), solve();
return 0;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
There are n cities in Treeland connected with n - 1 bidirectional roads in such that a way that any city is reachable from any other; in other words, the graph of cities and roads is a tree. Treeland is preparing for a seasonal virus epidemic, and currently, they are trying to evaluate different infection scenarios.
In each scenario, several cities are initially infected with different virus species. Suppose that there are k_i virus species in the i-th scenario. Let us denote v_j the initial city for the virus j, and s_j the propagation speed of the virus j. The spread of the viruses happens in turns: first virus 1 spreads, followed by virus 2, and so on. After virus k_i spreads, the process starts again from virus 1.
A spread turn of virus j proceeds as follows. For each city x not infected with any virus at the start of the turn, at the end of the turn it becomes infected with virus j if and only if there is such a city y that:
* city y was infected with virus j at the start of the turn;
* the path between cities x and y contains at most s_j edges;
* all cities on the path between cities x and y (excluding y) were uninfected with any virus at the start of the turn.
Once a city is infected with a virus, it stays infected indefinitely and can not be infected with any other virus. The spread stops once all cities are infected.
You need to process q independent scenarios. Each scenario is described by k_i virus species and m_i important cities. For each important city determine which the virus it will be infected by in the end.
Input
The first line contains a single integer n (1 β€ n β€ 2 β
10^5) β the number of cities in Treeland.
The following n - 1 lines describe the roads. The i-th of these lines contains two integers x_i and y_i (1 β€ x_i, y_i β€ n) β indices of cities connecting by the i-th road. It is guaranteed that the given graph of cities and roads is a tree.
The next line contains a single integer q (1 β€ q β€ 2 β
10^5) β the number of infection scenarios. q scenario descriptions follow.
The description of the i-th scenario starts with a line containing two integers k_i and m_i (1 β€ k_i, m_i β€ n) β the number of virus species and the number of important cities in this scenario respectively. It is guaranteed that β_{i = 1}^ q k_i and β_{i = 1}^ q m_i do not exceed 2 β
10^5.
The following k_i lines describe the virus species. The j-th of these lines contains two integers v_j and s_j (1 β€ v_j β€ n, 1 β€ s_j β€ 10^6) β the initial city and the propagation speed of the virus species j. It is guaranteed that the initial cities of all virus species within a scenario are distinct.
The following line contains m_i distinct integers u_1, β¦, u_{m_i} (1 β€ u_j β€ n) β indices of important cities.
Output
Print q lines. The i-th line should contain m_i integers β indices of virus species that cities u_1, β¦, u_{m_i} are infected with at the end of the i-th scenario.
Example
Input
7
1 2
1 3
2 4
2 5
3 6
3 7
3
2 2
4 1
7 1
1 3
2 2
4 3
7 1
1 3
3 3
1 1
4 100
7 100
1 2 3
Output
1 2
1 1
1 1 1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &x) {
x = 0;
char c = getchar();
bool flag = false;
while (!isdigit(c)) {
if (c == '-') flag = true;
c = getchar();
}
while (isdigit(c)) {
x = (x << 1) + (x << 3) + (c ^ 48);
c = getchar();
}
if (flag) x = -x;
}
int n, m, k, t, cnt, top, tot;
int in[800010], out[800010], tp[800010], f[800010], son[800010], dep[800010],
siz[800010];
int q[800010], st[800010], fa[800010], col[800010], bel[800010], s[800010],
sp[800010];
struct edge {
int to, nxt;
} e[800010];
int head[800010], edge_cnt;
void add(int from, int to) {
e[++edge_cnt] = {to, head[from]}, head[from] = edge_cnt;
}
bool cmp(const int &a, const int &b) { return in[a] < in[b]; }
void dfs_son(int x, int fath) {
siz[x] = 1, f[x] = fath, dep[x] = dep[fath] + 1;
for (int i = head[x]; i; i = e[i].nxt) {
int y = e[i].to;
if (y == fath) continue;
dfs_son(y, x), siz[x] += siz[y];
if (siz[son[x]] < siz[y]) son[x] = y;
}
}
void dfs_chain(int x, int t) {
in[x] = ++cnt, tp[x] = t;
if (son[x]) dfs_chain(son[x], t);
for (int i = head[x]; i; i = e[i].nxt) {
int y = e[i].to;
if (in[y]) continue;
dfs_chain(y, y);
}
out[x] = cnt;
}
int lca(int x, int y) {
while (tp[x] != tp[y]) {
if (dep[tp[x]] < dep[tp[y]]) swap(x, y);
x = f[tp[x]];
}
if (in[x] > in[y]) swap(x, y);
return x;
}
int dis(int x, int y) { return dep[x] + dep[y] - dep[lca(x, y)] * 2; }
int calc(int x, int y) { return (dis(x, y) + sp[col[x]] - 1) / sp[col[x]]; }
void build() {
sort(s + 1, s + tot + 1, cmp);
for (int i = tot - 1; i; --i) s[++tot] = lca(s[i], s[i + 1]);
sort(s + 1, s + tot + 1, cmp), tot = unique(s + 1, s + tot + 1) - s - 1,
top = 0;
for (int i = 1; i <= tot; ++i) {
while (top && out[st[top]] < in[s[i]]) top--;
if (top) fa[s[i]] = st[top];
st[++top] = s[i];
}
}
int get(int x, int a, int b) {
if (!x) return 0;
if (!a || !b) return a + b;
int da = calc(a, x), db = calc(b, x);
if (da == db) return col[a] < col[b] ? a : b;
return da < db ? a : b;
}
void clear() {
for (int i = 1; i <= tot; ++i) fa[s[i]] = bel[s[i]] = 0;
tot = 0;
}
int main() {
read(n);
for (int i = 1; i < n; ++i) {
int x, y;
read(x), read(y);
add(x, y), add(y, x);
}
dfs_son(1, 0), dfs_chain(1, 1);
read(m);
while (m--) {
read(k), read(t);
for (int i = 1; i <= k; ++i) {
int x;
read(x), read(sp[i]);
col[x] = i, bel[x] = x, s[++tot] = x;
}
for (int i = 1; i <= t; ++i) {
int x;
read(x), s[++tot] = x, q[i] = x;
}
build();
for (int i = tot; i; --i)
bel[fa[s[i]]] = get(fa[s[i]], bel[fa[s[i]]], bel[s[i]]);
for (int i = 1; i <= tot; ++i)
bel[s[i]] = get(s[i], bel[fa[s[i]]], bel[s[i]]);
for (int i = 1; i <= t; ++i) printf("%d%c", col[bel[q[i]]], " \n"[i == t]);
clear();
}
return 0;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
You are an adventurer currently journeying inside an evil temple. After defeating a couple of weak zombies, you arrived at a square room consisting of tiles forming an n Γ n grid. The rows are numbered 1 through n from top to bottom, and the columns are numbered 1 through n from left to right. At the far side of the room lies a door locked with evil magical forces. The following inscriptions are written on the door:
The cleaning of all evil will awaken the door!
Being a very senior adventurer, you immediately realize what this means. You notice that every single cell in the grid are initially evil. You should purify all of these cells.
The only method of tile purification known to you is by casting the "Purification" spell. You cast this spell on a single tile β then, all cells that are located in the same row and all cells that are located in the same column as the selected tile become purified (including the selected tile)! It is allowed to purify a cell more than once.
You would like to purify all n Γ n cells while minimizing the number of times you cast the "Purification" spell. This sounds very easy, but you just noticed that some tiles are particularly more evil than the other tiles. You cannot cast the "Purification" spell on those particularly more evil tiles, not even after they have been purified. They can still be purified if a cell sharing the same row or the same column gets selected by the "Purification" spell.
Please find some way to purify all the cells with the minimum number of spells cast. Print -1 if there is no such way.
Input
The first line will contain a single integer n (1 β€ n β€ 100). Then, n lines follows, each contains n characters. The j-th character in the i-th row represents the cell located at row i and column j. It will be the character 'E' if it is a particularly more evil cell, and '.' otherwise.
Output
If there exists no way to purify all the cells, output -1. Otherwise, if your solution casts x "Purification" spells (where x is the minimum possible number of spells), output x lines. Each line should consist of two integers denoting the row and column numbers of the cell on which you should cast the "Purification" spell.
Examples
Input
3
.E.
E.E
.E.
Output
1 1
2 2
3 3
Input
3
EEE
E..
E.E
Output
-1
Input
5
EE.EE
E.EE.
E...E
.EE.E
EE.EE
Output
3 3
1 3
2 2
4 4
5 3
Note
The first example is illustrated as follows. Purple tiles are evil tiles that have not yet been purified. Red tile is the tile on which "Purification" is cast. Yellow tiles are the tiles being purified as a result of the current "Purification" spell. Green tiles are tiles that have been purified previously.
<image>
In the second example, it is impossible to purify the cell located at row 1 and column 1.
For the third example:
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int cnt = 0;
bool dfs(const vector<vector<bool> >& a, vector<pair<int, int> >& res) {
for (int i = 0; i < a.size(); ++i) {
bool foo = true;
for (int j = 0; j < a.size(); ++j) {
if (!a[i][j]) {
foo = false;
res.push_back(make_pair(i, j));
break;
}
}
if (foo) {
return false;
}
}
return true;
}
int main() {
int N;
cin >> N;
vector<vector<bool> > a(N, vector<bool>(N, false));
getchar();
for (int i = 0; i < N; ++i) {
char ch = getchar();
for (int j = 0; j < N; j++, ch = getchar()) {
if (ch == 'E') {
a[i][j] = 1;
}
}
}
vector<bool> v(N, false), h(N, false);
vector<pair<int, int> > res;
res.reserve(N);
if (dfs(a, res)) {
for (int i = 0; i < res.size(); ++i) {
printf("%d %d\n", res[i].first + 1, res[i].second + 1);
}
return 0;
}
for (int i = 0; i < N; ++i) {
for (int j = i + 1; j < N; ++j) {
bool t = a[i][j];
a[i][j] = a[j][i];
a[j][i] = t;
}
}
res.clear();
if (dfs(a, res)) {
for (int i = 0; i < res.size(); ++i) {
printf("%d %d\n", res[i].second + 1, res[i].first + 1);
}
return 0;
}
cout << -1 << endl;
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
A class of students wrote a multiple-choice test.
There are n students in the class. The test had m questions, each of them had 5 possible answers (A, B, C, D or E). There is exactly one correct answer for each question. The correct answer for question i worth a_i points. Incorrect answers are graded with zero points.
The students remember what answers they gave on the exam, but they don't know what are the correct answers. They are very optimistic, so they want to know what is the maximum possible total score of all students in the class.
Input
The first line contains integers n and m (1 β€ n, m β€ 1000) β the number of students in the class and the number of questions in the test.
Each of the next n lines contains string s_i (|s_i| = m), describing an answer of the i-th student. The j-th character represents the student answer (A, B, C, D or E) on the j-th question.
The last line contains m integers a_1, a_2, β¦, a_m (1 β€ a_i β€ 1000) β the number of points for the correct answer for every question.
Output
Print a single integer β the maximum possible total score of the class.
Examples
Input
2 4
ABCD
ABCE
1 2 3 4
Output
16
Input
3 3
ABC
BCD
CDE
5 4 12
Output
21
Note
In the first example, one of the most optimal test answers is "ABCD", this way the total number of points will be 16.
In the second example, one of the most optimal test answers is "CCC", this way each question will be answered by exactly one student and the total number of points is 5 + 4 + 12 = 21.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long n, m;
string s[1005];
long long a[1005];
long long ans;
long long b[1005][5];
long long ma;
int comp2d(const void *pa, const void *push_back) {
int *a = (int *)pa;
int *b = (int *)push_back;
return a[2] - b[2];
}
long long mod(long long a, long long b) {
while (a < 0) a += b;
return a % b;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
for (long long(i) = (1); i < (n + 1); i++) cin >> s[i];
for (long long(i) = 0; i < (m); i++) cin >> a[i];
for (long long(i) = 0; i < (m); i++) {
ma = 0;
for (long long j = 1; j <= n; j++) {
b[i][s[j][i] - 'A']++;
}
for (long long j = 0; j < 5; j++) {
ma = max(ma, b[i][j]);
}
ans += ma * a[i];
}
cout << ans;
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
You are given an array s consisting of n integers.
You have to find any array t of length k such that you can cut out maximum number of copies of array t from array s.
Cutting out the copy of t means that for each element t_i of array t you have to find t_i in s and remove it from s. If for some t_i you cannot find such element in s, then you cannot cut out one more copy of t. The both arrays can contain duplicate elements.
For example, if s = [1, 2, 3, 2, 4, 3, 1] and k = 3 then one of the possible answers is t = [1, 2, 3]. This array t can be cut out 2 times.
* To cut out the first copy of t you can use the elements [1, \underline{2}, 3, 2, 4, \underline{3}, \underline{1}] (use the highlighted elements). After cutting out the first copy of t the array s can look like [1, 3, 2, 4].
* To cut out the second copy of t you can use the elements [\underline{1}, \underline{3}, \underline{2}, 4]. After cutting out the second copy of t the array s will be [4].
Your task is to find such array t that you can cut out the copy of t from s maximum number of times. If there are multiple answers, you may choose any of them.
Input
The first line of the input contains two integers n and k (1 β€ k β€ n β€ 2 β
10^5) β the number of elements in s and the desired number of elements in t, respectively.
The second line of the input contains exactly n integers s_1, s_2, ..., s_n (1 β€ s_i β€ 2 β
10^5).
Output
Print k integers β the elements of array t such that you can cut out maximum possible number of copies of this array from s. If there are multiple answers, print any of them. The required array t can contain duplicate elements. All the elements of t (t_1, t_2, ..., t_k) should satisfy the following condition: 1 β€ t_i β€ 2 β
10^5.
Examples
Input
7 3
1 2 3 2 4 3 1
Output
1 2 3
Input
10 4
1 3 1 3 10 3 7 7 12 3
Output
7 3 1 3
Input
15 2
1 2 1 1 1 2 1 1 2 1 2 1 1 1 1
Output
1 1
Note
The first example is described in the problem statement.
In the second example the only answer is [7, 3, 1, 3] and any its permutations. It can be shown that you cannot choose any other array such that the maximum number of copies you can cut out would be equal to 2.
In the third example the array t can be cut out 5 times.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 1;
int n, k;
pair<int, int> cnt[N];
bool solve(int a) {
int res = 0;
for (int i = 0; i < n; ++i) res += cnt[i].first / a;
return res >= k;
}
int main() {
ios_base::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
cin >> n >> k;
for (int i = 0; i < n; ++i) {
int first;
cin >> first;
++cnt[first].first;
cnt[first].second = first;
}
sort(cnt, cnt + N, greater<pair<int, int>>());
int lo = 0, hi = n + 1;
while (lo + 1 < hi) {
int mid = (lo + hi) / 2;
if (solve(mid))
lo = mid;
else
hi = mid;
}
vector<int> ans;
for (int i = 0; i < n; ++i)
while (ans.size() < k && cnt[i].first >= lo) {
ans.push_back(cnt[i].second);
cnt[i].first -= lo;
}
for (int el : ans) cout << el << ' ';
cout << '\n';
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
Once upon a time in the thicket of the mushroom forest lived mushroom gnomes. They were famous among their neighbors for their magic mushrooms. Their magic nature made it possible that between every two neighboring mushrooms every minute grew another mushroom with the weight equal to the sum of weights of two neighboring ones.
The mushroom gnomes loved it when everything was in order, that's why they always planted the mushrooms in one line in the order of their weights' increasing. Well... The gnomes planted the mushrooms and went to eat. After x minutes they returned and saw that new mushrooms had grown up, so that the increasing order had been violated. The gnomes replanted all the mushrooms in the correct order, that is, they sorted the mushrooms in the order of the weights' increasing. And went to eat again (those gnomes were quite big eaters). What total weights modulo p will the mushrooms have in another y minutes?
Input
The first line contains four integers n, x, y, p (1 β€ n β€ 106, 0 β€ x, y β€ 1018, x + y > 0, 2 β€ p β€ 109) which represent the number of mushrooms, the number of minutes after the first replanting, the number of minutes after the second replanting and the module. The next line contains n integers ai which represent the mushrooms' weight in the non-decreasing order (0 β€ ai β€ 109).
Please, do not use %lld specificator to read or write 64-bit integers in C++. It is preffered to use cin (also you may use %I64d).
Output
The answer should contain a single number which is the total weights of the mushrooms modulo p in the end after x + y minutes.
Examples
Input
2 1 0 657276545
1 2
Output
6
Input
2 1 1 888450282
1 2
Output
14
Input
4 5 0 10000
1 2 3 4
Output
1825
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int N;
long long P;
long long x, y;
long long a[1000005];
inline long long modsq(long long x) { return (x * x) % P; }
long long modpow(long long x, long long n) {
if (n == 0) return 1LL;
if (n % 2 == 0) return modsq(modpow(x, n / 2));
return ((modsq(modpow(x, n / 2))) * x) % P;
}
inline void mult(long long *a00, long long *a01, long long *a10, long long *a11,
long long b00, long long b01, long long b10, long long b11) {
long long c00 = ((*a00 * b00) % P + (*a01 * b10) % P) % P;
long long c01 = ((*a00 * b01) % P + (*a01 * b11) % P) % P;
long long c10 = ((*a10 * b00) % P + (*a11 * b10) % P) % P;
long long c11 = ((*a10 * b01) % P + (*a11 * b11) % P) % P;
*a00 = c00;
*a01 = c01;
*a10 = c10;
*a11 = c11;
}
void go(long long *a00, long long *a01, long long *a10, long long *a11,
long long n) {
if (n == 0) {
*a00 = 1;
*a01 = 0;
*a10 = 0;
*a11 = 1;
return;
}
if (n % 2 == 1) {
long long b00 = *a00;
long long b01 = *a01;
long long b10 = *a10;
long long b11 = *a11;
go(a00, a01, a10, a11, n / 2);
mult(a00, a01, a10, a11, *a00, *a01, *a10, *a11);
mult(a00, a01, a10, a11, b00, b01, b10, b11);
} else {
go(a00, a01, a10, a11, n / 2);
mult(a00, a01, a10, a11, *a00, *a01, *a10, *a11);
}
}
int main(void) {
cin >> N >> x >> y >> P;
if (x == 0) swap(x, y);
for (int i = 0; i < N; ++i) {
cin >> a[i];
a[i] %= P;
}
if (N == 1) {
cout << a[0] % P << "\n";
return 0;
}
long long a00 = +3;
long long a01 = +0;
long long a10 = P - 1;
long long a11 = +1;
go(&a00, &a01, &a10, &a11, x);
long long b00 = +3;
long long b01 = +0;
long long b10 = P - 1;
long long b11 = +1;
go(&b00, &b01, &b10, &b11, y);
long long c00 = +0;
long long c01 = +1;
long long c10 = +1;
long long c11 = +1;
go(&c00, &c01, &c10, &c11, x + 1);
long long g =
((a00 * b00) % P + (a01 * b10) % P + (a10 * b00) % P + (a11 * b10) % P) %
P;
long long f = (modpow(3, x) * modpow(3, y)) % P;
long long g0 = (b00 + b10) % P;
long long Sol = 0;
for (int i = 1; i < N - 1; ++i) {
Sol = (Sol + (f * a[i]) % P) % P;
}
Sol = (Sol + (g * a[0]) % P) % P;
Sol = (Sol + (g * a[N - 1]) % P) % P;
long long best = ((c00 * (a[N - 2])) % P + (c10 * (a[N - 1])) % P) % P;
if (y) {
Sol = (Sol + P - ((g0 * a[N - 1]) % P)) % P;
Sol = (Sol + P - ((modpow(3, y) * best) % P)) % P;
Sol = (Sol + (g0 * best) % P) % P;
Sol = (Sol + (modpow(3, y) * a[N - 1]) % P) % P;
}
cout << Sol << "\n";
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
Give a pair of integers (A, B) such that A^5-B^5 = X. It is guaranteed that there exists such a pair for the given integer X.
Constraints
* 1 \leq X \leq 10^9
* X is an integer.
* There exists a pair of integers (A, B) satisfying the condition in Problem Statement.
Input
Input is given from Standard Input in the following format:
X
Output
Print A and B, with space in between. If there are multiple pairs of integers (A, B) satisfying the condition, you may print any of them.
A B
Output
Print A and B, with space in between. If there are multiple pairs of integers (A, B) satisfying the condition, you may print any of them.
A B
Examples
Input
33
Output
2 -1
Input
1
Output
0 -1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long n, m, j, i, k, s;
int main(){
scanf("%d", &n);
for(i=-4999; i<=5000; i++){
for(j=-1000; j<=1000; j++){
k=i*i*i*i*i-j*j*j*j*j;
if(k==n){
printf("%d %d\n", i, j);
break;
}
}
if(k==n) break;
}
return 0;
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
You are given two strings s and t. In a single move, you can choose any of two strings and delete the first (that is, the leftmost) character. After a move, the length of the string decreases by 1. You can't choose a string if it is empty.
For example:
* by applying a move to the string "where", the result is the string "here",
* by applying a move to the string "a", the result is an empty string "".
You are required to make two given strings equal using the fewest number of moves. It is possible that, in the end, both strings will be equal to the empty string, and so, are equal to each other. In this case, the answer is obviously the sum of the lengths of the initial strings.
Write a program that finds the minimum number of moves to make two given strings s and t equal.
Input
The first line of the input contains s. In the second line of the input contains t. Both strings consist only of lowercase Latin letters. The number of letters in each string is between 1 and 2β
10^5, inclusive.
Output
Output the fewest number of moves required. It is possible that, in the end, both strings will be equal to the empty string, and so, are equal to each other. In this case, the answer is obviously the sum of the lengths of the given strings.
Examples
Input
test
west
Output
2
Input
codeforces
yes
Output
9
Input
test
yes
Output
7
Input
b
ab
Output
1
Note
In the first example, you should apply the move once to the first string and apply the move once to the second string. As a result, both strings will be equal to "est".
In the second example, the move should be applied to the string "codeforces" 8 times. As a result, the string becomes "codeforces" β "es". The move should be applied to the string "yes" once. The result is the same string "yes" β "es".
In the third example, you can make the strings equal only by completely deleting them. That is, in the end, both strings will be empty.
In the fourth example, the first character of the second string should be deleted.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s1, s2;
cin >> s1 >> s2;
int i = 0;
int mov = 0, n = s2.size();
for (auto it = s1.rbegin(); it != s1.rend(); ++it) {
if (*it == s2[n - i - 1]) {
mov += 1;
} else
break;
i++;
}
mov = s1.size() + s2.size() - (2 * mov);
cout << mov << "\n";
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
You are given a string S of length N consisting of `A`, `C`, `G` and `T`. Answer the following Q queries:
* Query i (1 \leq i \leq Q): You will be given integers l_i and r_i (1 \leq l_i < r_i \leq N). Consider the substring of S starting at index l_i and ending at index r_i (both inclusive). In this string, how many times does `AC` occurs as a substring?
Constraints
* 2 \leq N \leq 10^5
* 1 \leq Q \leq 10^5
* S is a string of length N.
* Each character in S is `A`, `C`, `G` or `T`.
* 1 \leq l_i < r_i \leq N
Input
Input is given from Standard Input in the following format:
N Q
S
l_1 r_1
:
l_Q r_Q
Output
Print Q lines. The i-th line should contain the answer to the i-th query.
Example
Input
8 3
ACACTACG
3 7
2 3
1 8
Output
2
0
3
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n,q;
cin >> n >> q;
string s;
cin >> s;
int a[n];
a[0]=0;
for(int i=1;i<n;i++){
a[i]=a[i-1];
if(s[i-1]=='A'&&s[i]=='C') a[i]++;
}
for(int i=0;i<q;i++){
int l,r;
cin >> l >> r;
cout << a[r-1]-a[l-1] << endl;
}
}
``` |
### Prompt
Generate a cpp solution to the following problem:
Sonya has an array a_1, a_2, β¦, a_n consisting of n integers and also one non-negative integer x. She has to perform m queries of two types:
* 1 i y: replace i-th element by value y, i.e. to perform an operation a_{i} := y;
* 2 l r: find the number of pairs (L, R) that lβ€ Lβ€ Rβ€ r and bitwise OR of all integers in the range [L, R] is at least x (note that x is a constant for all queries).
Can you help Sonya perform all her queries?
Bitwise OR is a binary operation on a pair of non-negative integers. To calculate the bitwise OR of two numbers, you need to write both numbers in binary notation. The result is a number, in binary, which contains a one in each digit if there is a one in the binary notation of at least one of the two numbers. For example, 10 OR 19 = 1010_2 OR 10011_2 = 11011_2 = 27.
Input
The first line contains three integers n, m, and x (1β€ n, mβ€ 10^5, 0β€ x<2^{20}) β the number of numbers, the number of queries, and the constant for all queries.
The second line contains n integers a_1, a_2, β¦, a_n (0β€ a_i<2^{20}) β numbers of the array.
The following m lines each describe an query. A line has one of the following formats:
* 1 i y (1β€ iβ€ n, 0β€ y<2^{20}), meaning that you have to replace a_{i} by y;
* 2 l r (1β€ lβ€ rβ€ n), meaning that you have to find the number of subarrays on the segment from l to r that the bitwise OR of all numbers there is at least x.
Output
For each query of type 2, print the number of subarrays such that the bitwise OR of all the numbers in the range is at least x.
Examples
Input
4 8 7
0 3 6 1
2 1 4
2 3 4
1 1 7
2 1 4
2 1 3
2 1 1
1 3 0
2 1 4
Output
5
1
7
4
1
4
Input
5 5 7
6 0 3 15 2
2 1 5
1 4 4
2 1 5
2 3 5
2 1 4
Output
9
7
2
4
Note
In the first example, there are an array [0, 3, 6, 1] and queries:
1. on the segment [1β¦4], you can choose pairs (1, 3), (1, 4), (2, 3), (2, 4), and (3, 4);
2. on the segment [3β¦4], you can choose pair (3, 4);
3. the first number is being replacing by 7, after this operation, the array will consist of [7, 3, 6, 1];
4. on the segment [1β¦4], you can choose pairs (1, 1), (1, 2), (1, 3), (1, 4), (2, 3), (2, 4), and (3, 4);
5. on the segment [1β¦3], you can choose pairs (1, 1), (1, 2), (1, 3), and (2, 3);
6. on the segment [1β¦1], you can choose pair (1, 1);
7. the third number is being replacing by 0, after this operation, the array will consist of [7, 3, 0, 1];
8. on the segment [1β¦4], you can choose pairs (1, 1), (1, 2), (1, 3), and (1, 4).
In the second example, there are an array [6, 0, 3, 15, 2] are queries:
1. on the segment [1β¦5], you can choose pairs (1, 3), (1, 4), (1, 5), (2, 4), (2, 5), (3, 4), (3, 5), (4, 4), and (4, 5);
2. the fourth number is being replacing by 4, after this operation, the array will consist of [6, 0, 3, 4, 2];
3. on the segment [1β¦5], you can choose pairs (1, 3), (1, 4), (1, 5), (2, 4), (2, 5), (3, 4), and (3, 5);
4. on the segment [3β¦5], you can choose pairs (3, 4) and (3, 5);
5. on the segment [1β¦4], you can choose pairs (1, 3), (1, 4), (2, 4), and (3, 4).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
mt19937 gen(chrono::system_clock::now().time_since_epoch().count());
const int M = 1e9 + 7;
const int FFTM = 998244353;
const int N = 1e5 + 7;
int X;
struct node {
long long res;
vector<pair<int, int> > pref, suff;
node() { res = 0; }
node(int x) {
res = (x >= X);
pref.push_back({x, 1});
suff.push_back({x, 1});
}
node operator+(const node &r) {
node ret;
ret.res = res + r.res;
ret.pref = pref;
for (auto it : r.pref) {
if (!ret.pref.empty() &&
(it.first | ret.pref.back().first) == ret.pref.back().first)
ret.pref.back().second += it.second;
else
ret.pref.push_back(
{it.first | (ret.pref.empty() ? 0 : ret.pref.back().first),
it.second});
}
ret.suff = r.suff;
for (auto it : suff) {
if (!ret.suff.empty() &&
(it.first | ret.suff.back().first) == ret.suff.back().first)
ret.suff.back().second += it.second;
else
ret.suff.push_back(
{it.first | (ret.suff.empty() ? 0 : ret.suff.back().first),
it.second});
}
int j = suff.size() - 1;
int cur = 0;
for (auto it : r.pref) {
while (j >= 0 && (it.first | suff[j].first) >= X) cur += suff[j--].second;
ret.res += 1ll * it.second * cur;
}
return ret;
}
};
struct segtree {
int tn = 1;
vector<node> t;
void resize(int n) {
tn = 1;
while (tn <= n) tn <<= 1;
t.resize(tn << 1 | 1);
}
segtree() {}
void upd(int p, int x) {
for (t[p += tn] = node(x); p > 1; p >>= 1)
t[p >> 1] = ((p & 1) ? t[p ^ 1] + t[p] : t[p] + t[p ^ 1]);
}
node q(int v, int tl, int tr, int l, int r) {
if (tr <= l || r <= tl) return node();
if (l <= tl && tr <= r) return t[v];
int m = (tl + tr) >> 1;
return q(v << 1, tl, m, l, r) + q(v << 1 | 1, m, tr, l, r);
}
node q(int l, int r) { return q(1, 0, tn, l, r); }
};
int n, q, p, x, l, r, T;
segtree t;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> q >> X;
t.resize(n);
for (int i = 0; i < n; i++) cin >> x, t.upd(i, x);
while (q--) {
cin >> T;
if (T == 1) {
cin >> p >> x;
p--;
t.upd(p, x);
}
if (T == 2) {
cin >> l >> r;
l--;
cout << t.q(l, r).res << '\n';
}
}
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Johnny is playing a well-known computer game. The game are in some country, where the player can freely travel, pass quests and gain an experience.
In that country there are n islands and m bridges between them, so you can travel from any island to any other. In the middle of some bridges are lying ancient powerful artifacts. Johnny is not interested in artifacts, but he can get some money by selling some artifact.
At the start Johnny is in the island a and the artifact-dealer is in the island b (possibly they are on the same island). Johnny wants to find some artifact, come to the dealer and sell it. The only difficulty is that bridges are too old and destroying right after passing over them. Johnnie's character can't swim, fly and teleport, so the problem became too difficult.
Note that Johnny can't pass the half of the bridge, collect the artifact and return to the same island.
Determine if Johnny can find some artifact and sell it.
Input
The first line contains two integers n and m (1 β€ n β€ 3Β·105, 0 β€ m β€ 3Β·105) β the number of islands and bridges in the game.
Each of the next m lines contains the description of the bridge β three integers xi, yi, zi (1 β€ xi, yi β€ n, xi β yi, 0 β€ zi β€ 1), where xi and yi are the islands connected by the i-th bridge, zi equals to one if that bridge contains an artifact and to zero otherwise. There are no more than one bridge between any pair of islands. It is guaranteed that it's possible to travel between any pair of islands.
The last line contains two integers a and b (1 β€ a, b β€ n) β the islands where are Johnny and the artifact-dealer respectively.
Output
If Johnny can find some artifact and sell it print the only word "YES" (without quotes). Otherwise print the word "NO" (without quotes).
Examples
Input
6 7
1 2 0
2 3 0
3 1 0
3 4 1
4 5 0
5 6 0
6 4 0
1 6
Output
YES
Input
5 4
1 2 0
2 3 0
3 4 0
2 5 1
1 4
Output
NO
Input
5 6
1 2 0
2 3 0
3 1 0
3 4 0
4 5 1
5 3 0
1 2
Output
YES
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
vector<vector<pair<int, int> > > g, G;
bool vis[N], vis2[N];
int idx[N], low[N], id;
map<pair<int, int>, bool> br;
int cmp[N], cc;
bool has[N];
void dfs1(int u, int p) {
id++;
vis[u] = true;
idx[u] = low[u] = id;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i].first;
if (!vis[v]) {
dfs1(v, u);
low[u] = min(low[u], low[v]);
if (idx[u] < low[v]) {
br[make_pair(min(u, v), max(u, v))] = 1;
}
} else if (v != p) {
low[u] = min(low[u], idx[v]);
}
}
}
void dfs2(int u) {
vis2[u] = true;
cmp[u] = cc;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i].first;
if (!br[make_pair(min(u, v), max(u, v))]) {
if (g[u][i].second) has[cc] = true;
if (!vis2[v]) dfs2(v);
}
}
}
void dfs(int u, int p, int des, int f) {
if (u == des) {
if (f)
puts("YES");
else
puts("NO");
exit(0);
}
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i].first;
if (v != p) {
dfs(v, u, des, f + has[v] + G[u][i].second);
}
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
g.resize(n + 1);
G.resize(n + 1);
for (int i = 0, a, b, c; i < m; i++) {
scanf("%d%d%d", &a, &b, &c);
g[a].push_back(make_pair(b, c));
swap(a, b);
g[a].push_back(make_pair(b, c));
}
int src, des;
cin >> src >> des;
dfs1(1, -1);
for (int i = 1; i <= n; i++) {
if (!vis2[i]) {
cc++;
dfs2(i);
}
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < g[i].size(); j++) {
if (cmp[i] != cmp[g[i][j].first]) {
G[cmp[i]].push_back(make_pair(cmp[g[i][j].first], g[i][j].second));
}
}
}
dfs(cmp[src], -1, cmp[des], has[cmp[src]]);
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
Okabe needs to renovate the Future Gadget Laboratory after he tried doing some crazy experiments! The lab is represented as an n by n square grid of integers. A good lab is defined as a lab in which every number not equal to 1 can be expressed as the sum of a number in the same row and a number in the same column. In other words, for every x, y such that 1 β€ x, y β€ n and ax, y β 1, there should exist two indices s and t so that ax, y = ax, s + at, y, where ai, j denotes the integer in i-th row and j-th column.
Help Okabe determine whether a given lab is good!
Input
The first line of input contains the integer n (1 β€ n β€ 50) β the size of the lab.
The next n lines contain n space-separated integers denoting a row of the grid. The j-th integer in the i-th row is ai, j (1 β€ ai, j β€ 105).
Output
Print "Yes" if the given lab is good and "No" otherwise.
You can output each letter in upper or lower case.
Examples
Input
3
1 1 2
2 3 1
6 4 1
Output
Yes
Input
3
1 5 2
1 1 1
1 2 3
Output
No
Note
In the first sample test, the 6 in the bottom left corner is valid because it is the sum of the 2 above it and the 4 on the right. The same holds for every number not equal to 1 in this table, so the answer is "Yes".
In the second sample test, the 5 cannot be formed as the sum of an integer in the same row and an integer in the same column. Thus the answer is "No".
### Response
```cpp
#include <bits/stdc++.h>
int main() {
int n, s[51][51] = {{0}}, p[51 * 51][2] = {{0}}, j, i, ju = 0;
scanf("%d", &n);
for (j = 1; j <= n; j++)
for (i = 1; i <= n; i++) {
scanf("%d", &s[j][i]);
if (s[j][i] != 1) p[ju][0] = j, p[ju][1] = i, ju++;
}
if (n == 1) {
if (s[1][1] == 1)
printf("Yes\n");
else
printf("No\n");
} else if (ju == 0)
printf("Yes\n");
else {
int k;
for (k = 0; k < ju; k++) {
int t = 1;
for (j = 1; j <= n && t; j++) {
for (i = 1; i <= n && t; i++) {
if (s[p[k][0]][p[k][1]] == s[p[k][0]][i] + s[j][p[k][1]]) t = 0;
}
}
if (t) {
printf("No\n");
return 0;
}
}
printf("Yes\n");
}
return 0;
}
``` |
### Prompt
Create a solution in CPP for 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;
const int oo = 0x3f3f3f3f;
const int Max = 256;
const int MaxE = Max * 2;
struct edge {
int to;
edge *s;
};
edge E[MaxE], *hd[Max], *cp;
int n, k, D[Max];
int F[Max][Max], R[Max];
int mp[Max][Max];
int A[Max], Q[Max], qn;
void addEdge(int x, int y) { cp->to = y, cp->s = hd[x], hd[x] = cp++; }
inline void update(int &r, int d) {
if (d < r) r = d;
}
void dfs(int x, int f) {
for (edge *p = hd[x]; p; p = p->s)
if (p->to != f) dfs(p->to, x);
for (int i = 1; i <= n; i++) {
int &cr = F[x][i] = 0;
int dx = mp[x][i];
for (edge *p = hd[x]; p; p = p->s)
if (p->to != f) {
int y = p->to;
cr += dx < mp[y][i] ? min(R[y], F[y][i]) : F[y][i];
}
cr += D[dx];
if (x == i) cr += k;
if (dx < mp[f][i]) update(R[x], cr);
}
}
void aDfs(int x, int f, int g) {
if (g == 0) {
for (int i = 1; i <= n; i++)
if (mp[x][i] < mp[f][i] && F[x][i] == R[x]) {
aDfs(x, f, i);
return;
}
}
if (x == g) A[Q[qn++] = x] = x;
for (edge *p = hd[x]; p; p = p->s)
if (p->to != f) {
int y = p->to;
aDfs(y, x, mp[x][g] < mp[y][g] && R[y] < F[y][g] ? 0 : g);
}
}
int main() {
while (scanf("%d%d", &n, &k) != EOF && n) {
for (int i = 1; i < n; i++) scanf("%d", &D[i]);
D[n] = oo;
memset(hd, 0, sizeof(hd));
memset(mp, 0x3f, sizeof(mp));
cp = E;
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
mp[x][y] = mp[y][x] = 1;
addEdge(x, y);
addEdge(y, x);
}
for (int z = 1; z <= n; z++)
for (int x = 1; x <= n; x++)
for (int y = 1; y <= n; y++) update(mp[x][y], mp[x][z] + mp[z][y]);
for (int x = 1; x <= n; x++) mp[x][x] = 0;
memset(R, 0x3f, sizeof(R));
dfs(1, 0);
printf("%d\n", R[1]);
memset(A, -1, sizeof(A));
qn = 0;
aDfs(1, 0, 0);
for (int cq = 0; cq < qn; cq++) {
int x = Q[cq];
for (edge *p = hd[x]; p; p = p->s)
if (A[p->to] == -1) {
A[p->to] = A[x];
Q[qn++] = p->to;
}
}
for (int i = 1; i <= n; i++) printf("%d%c", A[i], i == n ? '\n' : ' ');
}
}
``` |
### Prompt
Create a solution in CPP for the following problem:
There are n cups of different sizes and three trays (bon festivals) A, B, and C, and these cups are placed on top of each of the three trays in a pile. However, in any tray, the smallest cup in the tray is on the bottom, the second smallest cup is on top, and the third smallest cup is on top, in ascending order. .. For example, the right side of the figure below shows a state in which n = 5 cups are placed on trays A, B, and C, respectively, with 2, 0, and 3 stacked.
<image>
In this way, given the initial state of the cups, how many moves should be made to move all the cups to either the A or C tray, observing the following rules 1-3. I want to find it.
(Rule 1) Only one cup can be moved at a time. It is the top cup (that is, the largest cup) of the cups in the tray.
(Rule 2) Do not stack small cups on top of large ones.
(Rule 3) Only tray A to B, B to A, B to C, C to B are allowed to move one cup directly, and A to C or C to A is allowed. Not done.
Given the initial state of n cups and the integer m, it is possible to determine if all the cups can be stacked together in either the A or C tray within m moves. Create a program that outputs the minimum number of movements in some cases and -1 in cases where it is not possible.
On the first line of the input file, n and m are written in this order with a space as the delimiter. 1 β€ n β€ 15 and 1 β€ m β€ 15000000. On the 2nd, 3rd, and 4th lines, some integers from 1 to n are divided into 3 groups and arranged in ascending order within each group. .. However, the number of them is written at the beginning of each line (before those integers). The integers on the second line (except the first one) represent the size of each cup stacked on tray A. Similarly, the integers on the third line (except the first one) represent the size of each cup stacked on tray B, and the integers on the fourth line (excluding the first one). (Except one) represents the size of each cup stacked on tray C.
Input example 1 | Input example 2 | Input example 3 | Input example 4
--- | --- | --- | ---
|
3 10 | 4 20 | 2 5 | 3 3
0 | 2 1 2 | 2 1 2 | 0
1 1 | 1 3 | 0 | 1 1
2 2 3 | 1 4 | 0 | 2 2 3
Output example 1 | Output example 2 | Output example 3 | Output example 4
9 | 3 | 0 | -1
input
The input consists of multiple datasets. Input ends when both n and m are 0. The number of datasets does not exceed 5.
output
For each dataset, the number of moves or -1 is output on one line.
Example
Input
3 10
0
1 1
2 2 3
4 20
2 1 2
1 3
1 4
2 5
2 1 2
0
0
3 3
0
1 1
2 2 3
0 0
Output
9
3
0
-1
### Response
```cpp
#include <stdio.h>
#include <stdlib.h>
int main(void){
int pow3[16], c[16];
int n, m, i, j, k, d, x, y, p;
pow3[0] = 1;
for(i = 1; i <= 15; ++i){
pow3[i] = pow3[i-1] * 3;
}
while(scanf("%d%d", &n, &m), n){
for(i = 0; i < 3; ++i){
for(scanf("%d", &j); j > 0; --j){
scanf("%d", &k);
c[n-k] = i; /* ηͺε·δ»γζΏγ */
}
}
p = 0;
x = 0;
for(i = n - 1; i >= 0; --i){
d = abs(p - c[i]);
x += pow3[i] * d;
if(d == 1){
p = 2 - p; /* εε―Ύε΄γ«η§»ε */
}
}
y = pow3[n] - 1 - x;
if(x > y){
x = y;
}
printf("%d\n", x > m ? -1 : x);
}
return 0;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
N programmers are going to participate in the preliminary stage of DDCC 20XX. Due to the size of the venue, however, at most 9 contestants can participate in the finals.
The preliminary stage consists of several rounds, which will take place as follows:
* All the N contestants will participate in the first round.
* When X contestants participate in some round, the number of contestants advancing to the next round will be decided as follows:
* The organizer will choose two consecutive digits in the decimal notation of X, and replace them with the sum of these digits. The number resulted will be the number of contestants advancing to the next round.
For example, when X = 2378, the number of contestants advancing to the next round will be 578 (if 2 and 3 are chosen), 2108 (if 3 and 7 are chosen), or 2315 (if 7 and 8 are chosen).
When X = 100, the number of contestants advancing to the next round will be 10, no matter which two digits are chosen.
* The preliminary stage ends when 9 or fewer contestants remain.
Ringo, the chief organizer, wants to hold as many rounds as possible. Find the maximum possible number of rounds in the preliminary stage.
Since the number of contestants, N, can be enormous, it is given to you as two integer sequences d_1, \ldots, d_M and c_1, \ldots, c_M, which means the following: the decimal notation of N consists of c_1 + c_2 + \ldots + c_M digits, whose first c_1 digits are all d_1, the following c_2 digits are all d_2, \ldots, and the last c_M digits are all d_M.
Constraints
* 1 \leq M \leq 200000
* 0 \leq d_i \leq 9
* d_1 \neq 0
* d_i \neq d_{i+1}
* c_i \geq 1
* 2 \leq c_1 + \ldots + c_M \leq 10^{15}
Input
Input is given from Standard Input in the following format:
M
d_1 c_1
d_2 c_2
:
d_M c_M
Output
Print the maximum possible number of rounds in the preliminary stage.
Examples
Input
2
2 2
9 1
Output
3
Input
3
1 1
0 8
7 1
Output
9
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
const int N = 1e6+100;
long long d[N],c[N];
int main(){
int n;
cin>>n;
unsigned long long ans=0;
for(int i=1;i<=n;i++){
cin>>d[i]>>c[i];
ans+=c[i];
}
ans--;
long long res=0;
for(int i=1;i<=n;i++){
res+=(d[i]*c[i]);
}
cout<<ans+(res-1)/9<<endl;
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
Gerald got tired of playing board games with the usual six-sided die, and he bought a toy called Randomizer. It functions as follows.
A Randomizer has its own coordinate plane on which a strictly convex polygon is painted, the polygon is called a basic polygon. If you shake a Randomizer, it draws some nondegenerate (i.e. having a non-zero area) convex polygon with vertices at some vertices of the basic polygon. The result of the roll (more precisely, the result of the shaking) is considered to be the number of points with integer coordinates, which were strictly inside (the points on the border are not considered) the selected polygon. Now Gerald is wondering: what is the expected result of shaking the Randomizer?
During the shaking the Randomizer considers all the possible non-degenerate convex polygons with vertices at the vertices of the basic polygon. Let's assume that there are k versions of the polygons. Then the Randomizer chooses each of them with probability <image>.
Input
The first line of the input contains a single integer n (3 β€ n β€ 100 000) β the number of vertices of the basic polygon.
Next n lines contain the coordinates of the vertices of the basic polygon. The i-th of these lines contain two integers xi and yi ( - 109 β€ xi, yi β€ 109) β the coordinates of the i-th vertex of the polygon. The vertices are given in the counter-clockwise order.
Output
Print the sought expected value with absolute or relative error at most 10 - 9.
Examples
Input
4
0 0
2 0
2 2
0 2
Output
0.2
Input
5
0 0
2 0
2 2
1 3
0 2
Output
0.8125
Note
A polygon is called strictly convex if it is convex and no its vertices lie on the same line.
Let's assume that a random variable takes values x1, ..., xn with probabilities p1, ..., pn, correspondingly. Then the expected value of this variable equals to <image>.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
long long r;
while (b != 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
const int maxn = 100010;
const int maxp = 60;
int n;
long long x[maxn];
long long y[maxn];
long double pw[maxn];
long double f[maxp];
void solve() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%I64d%I64d", x + i, y + i);
pw[0] = 1;
for (int i = 1; i < maxn; i++) pw[i] = pw[i - 1] * 0.5;
for (int i = 1; i < min(n, maxp); i++)
f[i] = (1.0 - pw[n - i - 1]) /
((1LL << (i + 1)) - (n * n + n + 2) * pw[n - i]);
long double ans = 0;
for (int j = 1; j < min(n - 1, maxp); j++)
for (int i = 0; i < n; i++) {
int k = (i + j) % n;
long long d = gcd(abs(x[k] - x[i]), abs(y[k] - y[i]));
ans += f[j] * (x[i] * y[k] - x[k] * y[i] - d);
}
cout << fixed << setprecision(9) << ans / 2 + 1;
}
int main() {
solve();
return 0;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
You are given a rectangular grid with n rows and m columns. The cell located on the i-th row from the top and the j-th column from the left has a value a_{ij} written in it.
You can perform the following operation any number of times (possibly zero):
* Choose any two adjacent cells and multiply the values in them by -1. Two cells are called adjacent if they share a side.
Note that you can use a cell more than once in different operations.
You are interested in X, the sum of all the numbers in the grid.
What is the maximum X you can achieve with these operations?
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 100). Description of the test cases follows.
The first line of each test case contains two integers n,m (2 β€ n, m β€ 10).
The following n lines contain m integers each, the j-th element in the i-th line is a_{ij} (-100β€ a_{ij}β€ 100).
Output
For each testcase, print one integer X, the maximum possible sum of all the values in the grid after applying the operation as many times as you want.
Example
Input
2
2 2
-1 1
1 1
3 4
0 -1 -2 -3
-1 -2 -3 -4
-2 -3 -4 -5
Output
2
30
Note
In the first test case, there will always be at least one -1, so the answer is 2.
In the second test case, we can use the operation six times to elements adjacent horizontally and get all numbers to be non-negative. So the answer is: 2Γ 1 + 3Γ2 + 3Γ 3 + 2Γ 4 + 1Γ 5 = 30.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int tc;
cin >> tc;
while (tc--) {
int n, m;
cin >> n >> m;
int cnt = 0;
int sum = 0;
int mi = 110;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
int a;
cin >> a;
sum += abs(a);
mi = min(mi, abs(a));
if (a < 0) cnt++;
}
}
cnt %= 2;
cout << (cnt ? sum - 2 * mi : sum) << '\n';
}
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
B: Hokkaido University Hard
Note
Please note that the question settings are the same as question A, except for the constraints.
story
Homura-chan, who passed Hokkaido University and is excited about the beginning of a new life. But in front of her, a huge campus awaits ...
"Eh ... I'm not in time for the next class ..."
problem
Hokkaido University Sapporo Campus is famous for being unusually large. The Sapporo campus is represented by rectangular squares with H squares vertically and W squares horizontally. We will use (i, j) to represent the cells that are i-mass from the north and j-mass from the west. There are several buildings on campus, with a'B'if there is a building in the location represented by the square (i, j) and a'.' If not, in c_ {i, j}.
Homura, a freshman at Hokkaido University, was surprised at the size of the campus and was worried about moving between buildings. So I was wondering how far the farthest of the two squares with the building were. Here we define the distance between two pairs of squares (i, j), (i', j') as | i-i'| + | j-j'|.
Homura found this problem difficult for him and asked his classmates for help. Please ask for an answer instead of Homura-chan.
Input format
H W
c_ {11} c_ {12} ... c_ {1W}
::
c_ {H1} c_ {H2} ... c_ {HW}
Constraint
* 2 \ leq H, W \ leq 10 ^ 3
* H and W are integers
* c_ {i, j} is either'B'or'.'.
* At least two of c_ {i, j} are'B'.
Output format
Print the integer that represents the answer on one line.
Input example 1
3 3
B.B
..B
.BB
Output example 1
Four
* The longest is between the two points (1,1) and (3,3).
Input example 2
4 3
B ..
B ..
...
...
Output example 2
1
* Adjacent positions may be the longest.
Input example 3
6 6
... B ..
B.B.B.
.B.B.B
... B.B
.B..B.
..B ...
Output example 3
7
Example
Input
3 3
B.B
..B
.BB
Output
4
### Response
```cpp
#include <iostream>
#include <iomanip>
#include <vector>
#include <algorithm>
#include <numeric>
#include <functional>
#include <cmath>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <sstream>
#include <string>
#define _repargs(_1,_2,_3,name,...) name
#define _rep(i,n) repi(i,0,n)
#define repi(i,a,b) for(int i=(int)(a);i<(int)(b);++i)
#define rep(...) _repargs(__VA_ARGS__,repi,_rep,)(__VA_ARGS__)
#define all(x) (x).begin(),(x).end()
#define mod 1000000007
#define inf 2000000007
#define mp make_pair
#define pb push_back
typedef long long ll;
using namespace std;
template <typename T>
inline void output(T a, int p = 0) {
if(p) cout << fixed << setprecision(p) << a << "\n";
else cout << a << "\n";
}
// end of template
int main() {
cin.tie(0);
ios::sync_with_stdio(0);
// source code
int H, W;
cin >> H >> W;
vector<string> A(H);
rep(i, H) cin >> A[i];
vector<int> B(H + W - 1), C(H + W - 1);
rep(i, H) rep(j, W) {
if(A[i][j] == 'B') {
B[i + j] = 1;
C[H - 1 - i + j] = 1;
}
}
int minB = inf, maxB = 0;
int minC = inf, maxC = 0;
rep(i, H + W - 1) {
if(B[i] == 1){
minB = min(minB, i);
maxB = max(maxB, i);
}
if(C[i] == 1) {
minC = min(minC, i);
maxC = max(maxC, i);
}
}
output(max(maxB - minB, maxC - minC));
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
<image>
The International Clown and Pierrot Competition (ICPC), is one of the most distinguished and also the most popular events on earth in the show business.
One of the unique features of this contest is the great number of judges that sometimes counts up to one hundred. The number of judges may differ from one contestant to another, because judges with any relationship whatsoever with a specific contestant are temporarily excluded for scoring his/her performance.
Basically, scores given to a contestant's performance by the judges are averaged to decide his/her score. To avoid letting judges with eccentric viewpoints too much influence the score, the highest and the lowest scores are set aside in this calculation. If the same highest score is marked by two or more judges, only one of them is ignored. The same is with the lowest score. The average, which may contain fractions, are truncated down to obtain final score as an integer.
You are asked to write a program that computes the scores of performances, given the scores of all the judges, to speed up the event to be suited for a TV program.
Input
The input consists of a number of datasets, each corresponding to a contestant's performance. There are no more than 20 datasets in the input.
A dataset begins with a line with an integer n, the number of judges participated in scoring the performance (3 β€ n β€ 100). Each of the n lines following it has an integral score s (0 β€ s β€ 1000) marked by a judge. No other characters except for digits to express these numbers are in the input. Judges' names are kept secret.
The end of the input is indicated by a line with a single zero in it.
Output
For each dataset, a line containing a single decimal integer indicating the score for the corresponding performance should be output. No other characters should be on the output line.
Example
Input
3
1000
342
0
5
2
2
9
11
932
5
300
1000
0
200
400
8
353
242
402
274
283
132
402
523
0
Output
342
7
300
326
### Response
```cpp
#include<iostream>
#include<algorithm>
using namespace std;
int main() {
int n;
while (cin >> n) {
if (n == 0)break;
int a[n];
int ans = 0;
for (int i = 0;i < n;i++) {
cin >> a[i];
ans += a[i];
}
sort(a, a + n);
ans -= a[0] + a[n - 1];
ans /= n - 2;
cout << ans << endl;
}
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
A non-empty string is called palindrome, if it reads the same from the left to the right and from the right to the left. For example, "abcba", "a", and "abba" are palindromes, while "abab" and "xy" are not.
A string is called a substring of another string, if it can be obtained from that string by dropping some (possibly zero) number of characters from the beginning and from the end of it. For example, "abc", "ab", and "c" are substrings of the string "abc", while "ac" and "d" are not.
Let's define a palindromic count of the string as the number of its substrings that are palindromes. For example, the palindromic count of the string "aaa" is 6 because all its substrings are palindromes, and the palindromic count of the string "abc" is 3 because only its substrings of length 1 are palindromes.
You are given a string s. You can arbitrarily rearrange its characters. You goal is to obtain a string with the maximum possible value of palindromic count.
Input
The first line contains an integer n (1 β€ n β€ 100 000) β the length of string s.
The second line contains string s that consists of exactly n lowercase characters of Latin alphabet.
Output
Print string t, which consists of the same set of characters (and each characters appears exactly the same number of times) as string s. Moreover, t should have the maximum possible value of palindromic count among all such strings strings.
If there are multiple such strings, print any of them.
Examples
Input
5
oolol
Output
ololo
Input
16
gagadbcgghhchbdf
Output
abccbaghghghgdfd
Note
In the first example, string "ololo" has 9 palindromic substrings: "o", "l", "o", "l", "o", "olo", "lol", "olo", "ololo". Note, that even though some substrings coincide, they are counted as many times as they appear in the resulting string.
In the second example, the palindromic count of string "abccbaghghghgdfd" is 29.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
string s;
cin >> s;
long long int a[26] = {0};
for (long long int i = 0; i < n; i++) a[s[i] - 'a']++;
for (long long int i = 0; i < 26; i++) {
while (a[i]--) {
cout << char(i + 'a');
}
}
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
Buses run between the cities A and B, the first one is at 05:00 AM and the last one departs not later than at 11:59 PM. A bus from the city A departs every a minutes and arrives to the city B in a ta minutes, and a bus from the city B departs every b minutes and arrives to the city A in a tb minutes.
The driver Simion wants to make his job diverse, so he counts the buses going towards him. Simion doesn't count the buses he meet at the start and finish.
You know the time when Simion departed from the city A to the city B. Calculate the number of buses Simion will meet to be sure in his counting.
Input
The first line contains two integers a, ta (1 β€ a, ta β€ 120) β the frequency of the buses from the city A to the city B and the travel time. Both values are given in minutes.
The second line contains two integers b, tb (1 β€ b, tb β€ 120) β the frequency of the buses from the city B to the city A and the travel time. Both values are given in minutes.
The last line contains the departure time of Simion from the city A in the format hh:mm. It is guaranteed that there are a bus from the city A at that time. Note that the hours and the minutes are given with exactly two digits.
Output
Print the only integer z β the number of buses Simion will meet on the way. Note that you should not count the encounters in cities A and B.
Examples
Input
10 30
10 35
05:20
Output
5
Input
60 120
24 100
13:00
Output
9
Note
In the first example Simion departs form the city A at 05:20 AM and arrives to the city B at 05:50 AM. He will meet the first 5 buses from the city B that departed in the period [05:00 AM - 05:40 AM]. Also Simion will meet a bus in the city B at 05:50 AM, but he will not count it.
Also note that the first encounter will be between 05:26 AM and 05:27 AM (if we suggest that the buses are go with the sustained speed).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
map<long long, long long> mp;
map<long long, long long> mp1;
long long a[20000000];
int main() {
cin.sync_with_stdio(false);
long long i, j, k, l, c, v, n, m, r, t;
long long x1, x2, y1, y2, x3, x4, x5, x6;
char sd;
string s, s1, s2, s3, ss[10000];
while (cin >> c >> v) {
cin >> k >> l;
cin >> n >> sd >> m;
long long m1 = n * 60 + m;
long long m2 = m1 + v;
c = 0;
for (i = 300; i < 24 * 60; i += k) {
if (((i + l) > m1) && ((i) < m2)) c++;
}
cout << c;
}
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
In the popular spreadsheets systems (for example, in Excel) the following numeration of columns is used. The first column has number A, the second β number B, etc. till column 26 that is marked by Z. Then there are two-letter numbers: column 27 has number AA, 28 β AB, column 52 is marked by AZ. After ZZ there follow three-letter numbers, etc.
The rows are marked by integer numbers starting with 1. The cell name is the concatenation of the column and the row numbers. For example, BC23 is the name for the cell that is in column 55, row 23.
Sometimes another numeration system is used: RXCY, where X and Y are integer numbers, showing the column and the row numbers respectfully. For instance, R23C55 is the cell from the previous example.
Your task is to write a program that reads the given sequence of cell coordinates and produce each item written according to the rules of another numeration system.
Input
The first line of the input contains integer number n (1 β€ n β€ 105), the number of coordinates in the test. Then there follow n lines, each of them contains coordinates. All the coordinates are correct, there are no cells with the column and/or the row numbers larger than 106 .
Output
Write n lines, each line should contain a cell coordinates in the other numeration system.
Examples
Input
2
R23C55
BC23
Output
BC23
R23C55
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int check(string t) {
int temp = 0;
for (int i = 0; i < t.length(); i++) {
if (isdigit(t[i])) temp = 1;
if (isalpha(t[i]) && temp) return 1;
}
return 0;
}
int main() {
string t;
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
string tt;
cin >> t;
if (check(t)) {
int ttt = 0, j = 1;
while (t[j] != 'C') tt.append(1, t[j++]);
j++;
while (t[j]) ttt = ttt * 10 + t[j++] - '0';
while (ttt) {
if (ttt % 26) {
tt.insert(0, 1, ttt % 26 + 'A' - 1);
} else {
tt.insert(0, 1, 'Z');
ttt -= 26;
}
ttt /= 26;
}
} else {
int ttt = 0, j = 0;
while (isalpha(t[j])) {
ttt = ttt * 26 + t[j] - 'A' + 1;
j++;
}
tt.append(1, 'R');
while (t[j]) tt.append(1, t[j++]);
tt.append(1, 'C');
int k = tt.length();
while (ttt) {
tt.insert(k, 1, ttt % 10 + '0');
ttt /= 10;
}
}
cout << tt << "\n";
}
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
Johnny has just found the new, great tutorial: "How to become a grandmaster?". The tutorial tells many strange and unexpected for Johnny things, such as you have to be patient or that very important is solving many harder and harder problems.
The boy has found an online judge with tasks divided by topics they cover. He has picked p^{k_i} problems from i-th category (p is his favorite number). He wants to solve them in two weeks (the patience condition is too hard for Johnny, so for simplicity, he looks only at easy tasks, which can be solved in such a period). Now our future grandmaster has to decide which topics to cover first and which the second week. Help him assign topics in such a way, that workload is balanced.
Formally, given n numbers p^{k_i}, the boy wants to divide them into two disjoint sets, minimizing the absolute difference between sums of numbers in each set. Find the minimal absolute difference. Output the result modulo 10^{9}+7.
Input
Input consists of multiple test cases. The first line contains one integer t (1 β€ t β€ 10^5) β the number of test cases. Each test case is described as follows:
The first line contains two integers n and p (1 β€ n, p β€ 10^6). The second line contains n integers k_i (0 β€ k_i β€ 10^6).
The sum of n over all test cases doesn't exceed 10^6.
Output
Output one integer β the reminder of division the answer by 1 000 000 007.
Example
Input
4
5 2
2 3 4 4 3
3 1
2 10 1000
4 5
0 1 1 100
1 8
89
Output
4
1
146981438
747093407
Note
You have to minimize the difference, not it's remainder. For example, if the minimum difference is equal to 2, but there is also a distribution where the difference is 10^9 + 8, then the answer is 2, not 1.
In the first test case of the example, there're the following numbers: 4, 8, 16, 16, and 8. We can divide them into such two sets: {4, 8, 16} and {8, 16}. Then the difference between the sums of numbers in sets would be 4.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
inline void add(int &a, int b, int md) {
a += b;
if (a >= md) a -= md;
}
inline void sub(int &a, int b, int md) {
a -= b;
if (a < 0) a += md;
}
inline int mul(int a, int b, int md) { return (int)((long long)a * b % md); }
int pow(int a, int b, int md) {
int res = 1;
while (b) {
if (b & 1) {
res = mul(res, a, md);
}
a = mul(a, a, md);
b >>= 1;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
const int p1 = 1e9 + 7;
const int p2 = 1000000021;
int t;
cin >> t;
while (t--) {
int n, p;
cin >> n >> p;
vector<int> k(n);
for (int i = 0; i < n; i++) {
cin >> k[i];
}
sort(k.begin(), k.end());
int s = 0, s2 = 0;
for (int i = n - 1; i >= 0; i--) {
if (s == 0 && s2 == 0) {
add(s, pow(p, k[i], p1), p1);
add(s2, pow(p, k[i], p2), p2);
} else {
sub(s, pow(p, k[i], p1), p1);
sub(s2, pow(p, k[i], p2), p2);
}
}
cout << s << endl;
}
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
Mishka is a little polar bear. As known, little bears loves spending their free time playing dice for chocolates. Once in a wonderful sunny morning, walking around blocks of ice, Mishka met her friend Chris, and they started playing the game.
Rules of the game are very simple: at first number of rounds n is defined. In every round each of the players throws a cubical dice with distinct numbers from 1 to 6 written on its faces. Player, whose value after throwing the dice is greater, wins the round. In case if player dice values are equal, no one of them is a winner.
In average, player, who won most of the rounds, is the winner of the game. In case if two players won the same number of rounds, the result of the game is draw.
Mishka is still very little and can't count wins and losses, so she asked you to watch their game and determine its result. Please help her!
Input
The first line of the input contains single integer n n (1 β€ n β€ 100) β the number of game rounds.
The next n lines contains rounds description. i-th of them contains pair of integers mi and ci (1 β€ mi, ci β€ 6) β values on dice upper face after Mishka's and Chris' throws in i-th round respectively.
Output
If Mishka is the winner of the game, print "Mishka" (without quotes) in the only line.
If Chris is the winner of the game, print "Chris" (without quotes) in the only line.
If the result of the game is draw, print "Friendship is magic!^^" (without quotes) in the only line.
Examples
Input
3
3 5
2 1
4 2
Output
Mishka
Input
2
6 1
1 6
Output
Friendship is magic!^^
Input
3
1 5
3 3
2 2
Output
Chris
Note
In the first sample case Mishka loses the first round, but wins second and third rounds and thus she is the winner of the game.
In the second sample case Mishka wins the first round, Chris wins the second round, and the game ends with draw with score 1:1.
In the third sample case Chris wins the first round, but there is no winner of the next two rounds. The winner of the game is Chris.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int count = 0;
int ans = 0;
for (int i = 0; i < n; i++) {
int m, c;
cin >> m >> c;
if (m > c) {
count++;
} else if (c > m) {
ans++;
}
}
if (count == ans) {
cout << "Friendship is magic!^^";
} else if (count > ans) {
cout << "Mishka";
} else {
cout << "Chris";
}
}
``` |
### Prompt
Create a solution in cpp for the following problem:
Taro is playing with a puzzle that places numbers 1-9 in 9x9 squares. In this puzzle, you have to arrange the numbers according to the following rules.
* One number appears exactly once in the same column
* A number appears exactly once on the same line
* In each of the 3x3 ranges separated by double lines, a number appears exactly once.
For example, Figure 1 below is one arrangement that meets such a rule. However, Taro often creates an arrangement that violates the rules, as shown in Figure 2. The "2" appears twice in the leftmost column, the "1" never appears, the "1" appears twice in the second column from the left, and the "2" never appears. ..
<image> | <image>
--- | ---
Figure 1 | Figure 2
To help Taro, write a program that reads the arrangement of numbers, checks if the arrangement meets the rules, and outputs the location if it violates the rules. Please display * (half-width asterisk) before the number that is incorrect (appears more than once) according to the three rules, and blank before the number that is not incorrect.
Input
Given multiple datasets. The first row gives the number of datasets n (n β€ 20). Each dataset is given a 9-character, 9-line numeric string that indicates the state of the puzzle.
Output
Output the following for each dataset.
Given number, * (half-width asterisk) and blank. Add * before the wrong number and a half-width space before the wrong number.
Insert a blank line between the datasets.
Example
Input
2
2 1 3 4 5 6 7 8 9
4 5 6 7 8 9 1 2 3
7 8 9 1 2 3 4 5 6
2 3 4 5 6 7 8 9 1
5 6 7 8 9 1 2 3 4
8 9 1 2 3 4 5 6 7
3 4 5 6 7 8 9 1 2
6 7 8 9 1 2 3 4 5
9 1 2 3 4 5 6 7 8
2 1 3 4 5 6 7 8 9
4 5 6 7 8 9 1 2 3
7 8 9 1 2 3 4 5 6
2 3 4 5 6 7 8 9 1
5 6 7 8 9 1 2 3 4
8 9 1 2 3 4 5 6 7
3 4 5 6 7 8 9 1 2
6 7 8 9 1 2 3 4 5
9 1 2 3 4 5 6 7 8
Output
*2*1 3 4 5 6 7 8 9
4 5 6 7 8 9 1 2 3
7 8 9 1 2 3 4 5 6
*2 3 4 5 6 7 8 9 1
5 6 7 8 9 1 2 3 4
8 9 1 2 3 4 5 6 7
3 4 5 6 7 8 9 1 2
6 7 8 9 1 2 3 4 5
9*1 2 3 4 5 6 7 8
*2*1 3 4 5 6 7 8 9
4 5 6 7 8 9 1 2 3
7 8 9 1 2 3 4 5 6
*2 3 4 5 6 7 8 9 1
5 6 7 8 9 1 2 3 4
8 9 1 2 3 4 5 6 7
3 4 5 6 7 8 9 1 2
6 7 8 9 1 2 3 4 5
9*1 2 3 4 5 6 7 8
### Response
```cpp
# define _CRT_SECURE_NO_WARNINGS 1
# include <iostream>
# include <string>
# include <bitset>
# include <vector>
# include <algorithm>
# include <cstdlib>
# include <cstdio>
# include <cstring>
# include <cstdlib>
# include <iomanip>
# include <queue>
# include <sstream>
# include <climits>
# include <cmath>
# include <list>
# include <functional>
# include <string>
# include <ctime>
# include <set>
# include <map>
# include <stack>
# include <unordered_map>
using namespace std;
//# define M_PI 3.141592
# define INF ((int)(1<<30))
# define FOR(i,n) for(int i=0;i<(int)n;i++)
# define FORI(i,k,n) for(int i=k;i<(int)n;i++)
# define toRad 2.0*M_PI/360.0
# define inin(x) int x;cin>>x;
# define all(x) x.begin(),x.end()
# define debug(x) cout<<#x<<" :"<<x<<endl;
# define rep(i,n) for(int i=0;i<(int)n;i++)
# define EPS 1e-12
# define CHECK(i,a) FOR(i,a.size())cout<<#a<<"["<<i<<"] : "<<a[i]<<endl;
int main()
{
int n; cin >> n;
bool f = false;
while (n--)
{
if (f)cout << endl;
f = true;
int a[9][9];
bool b[9][9];
for (int i = 0; i < 9; i++)
{
for (int j = 0; j < 9; j++)
{
cin >> a[i][j];
b[i][j] = false;
}
}
for (int i = 0; i < 9; i++)
{
for (int j = 0; j < 9; j++)
{
for (int k = 0; k < 9; k++)
{
if (k == j)continue;
if (a[i][j] == a[i][k])
{
b[i][j] = true;
b[i][k] = true;
}
if (a[j][i] == a[k][i])
{
b[j][i] = true;
b[k][i] = true;
}
}
if (i % 3 == 0 && j % 3 == 0)
{
for (int k = 0; k < 9; k++)
{
for (int l = 0; l < 9; l++)
{
if (i + k % 3 == i + l % 3 || j + k / 3 == j + l / 3)continue;
if (a[i + k % 3][j + k / 3] == a[i + l % 3][j + l / 3])
{
b[i + k % 3][j + k / 3] = true;
b[i + l % 3][j + l / 3] = true;
}
}
}
}
}
}
for (int i = 0; i < 9; i++)
{
for (int j = 0; j < 9; j++)
{
cout << (b[i][j] ? '*' : ' ');
cout << a[i][j];
}
cout << endl;
}
}
}
``` |
### Prompt
Generate 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>
using namespace std;
const int N = 1e5 + 7, MxN = 1e6 + 7, mod = 1e9 + 7, inf = 2e9 + 7;
const long long linf = (long long)1e18 + 7;
const double eps = 1e-9;
const int ii[] = {-1, 0, 1, 0, 1, -1, -1, 1},
jj[] = {0, 1, 0, -1, 1, -1, 1, -1};
int n, base = 100;
int dp[201][101][51][3];
bool was[201][101][51][3];
string s;
inline int Dp(int pos = 0, int x = 0, int k = 0, int go = 1) {
if (x == (int)s.size()) {
if (k < n) return -inf;
return abs(pos);
}
if (was[pos + base][x][k][go + 1]) return dp[pos + base][x][k][go + 1];
was[pos + base][x][k][go + 1] = 1;
int res = 0;
if (s[x] == 'F') {
res = max(res, Dp(pos + go, x + 1, k, go));
for (int i = 1; i <= n - k; i++) {
if (i % 2)
res = max(res, Dp(pos, x + 1, k + i, 0 - go));
else
res = max(res, Dp(pos + go, x + 1, k + i, go));
}
} else {
res = max(res, Dp(pos, x + 1, k, 0 - go));
for (int i = 1; i <= n - k; i++) {
if (i % 2)
res = max(res, Dp(pos + go, x + 1, k + i, go));
else
res = max(res, Dp(pos, x + 1, k + i, 0 - go));
}
}
return dp[pos + base][x][k][go + 1] = res;
}
int main() {
cin >> s >> n;
cout << Dp();
exit(0);
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
Nothing has changed since the last round. Dima and Inna still love each other and want to be together. They've made a deal with Seryozha and now they need to make a deal with the dorm guards...
There are four guardposts in Dima's dorm. Each post contains two guards (in Russia they are usually elderly women). You can bribe a guard by a chocolate bar or a box of juice. For each guard you know the minimum price of the chocolate bar she can accept as a gift and the minimum price of the box of juice she can accept as a gift. If a chocolate bar for some guard costs less than the minimum chocolate bar price for this guard is, or if a box of juice for some guard costs less than the minimum box of juice price for this guard is, then the guard doesn't accept such a gift.
In order to pass through a guardpost, one needs to bribe both guards.
The shop has an unlimited amount of juice and chocolate of any price starting with 1. Dima wants to choose some guardpost, buy one gift for each guard from the guardpost and spend exactly n rubles on it.
Help him choose a post through which he can safely sneak Inna or otherwise say that this is impossible. Mind you, Inna would be very sorry to hear that!
Input
The first line of the input contains integer n (1 β€ n β€ 105) β the money Dima wants to spend. Then follow four lines describing the guardposts. Each line contains four integers a, b, c, d (1 β€ a, b, c, d β€ 105) β the minimum price of the chocolate and the minimum price of the juice for the first guard and the minimum price of the chocolate and the minimum price of the juice for the second guard, correspondingly.
Output
In a single line of the output print three space-separated integers: the number of the guardpost, the cost of the first present and the cost of the second present. If there is no guardpost Dima can sneak Inna through at such conditions, print -1 in a single line.
The guardposts are numbered from 1 to 4 according to the order given in the input.
If there are multiple solutions, you can print any of them.
Examples
Input
10
5 6 5 6
6 6 7 7
5 8 6 6
9 9 9 9
Output
1 5 5
Input
10
6 6 6 6
7 7 7 7
4 4 4 4
8 8 8 8
Output
3 4 6
Input
5
3 3 3 3
3 3 3 3
3 3 3 3
3 3 3 3
Output
-1
Note
Explanation of the first example.
The only way to spend 10 rubles to buy the gifts that won't be less than the minimum prices is to buy two 5 ruble chocolates to both guards from the first guardpost.
Explanation of the second example.
Dima needs 12 rubles for the first guardpost, 14 for the second one, 16 for the fourth one. So the only guardpost we can sneak through is the third one. So, Dima can buy 4 ruble chocolate for the first guard and 6 ruble juice of the second guard.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long a, b, c, d, n;
while (cin >> n) {
long sum1, sum2, p, q;
int m = 0;
for (int i = 1; i <= 4; i++) {
cin >> a >> b >> c >> d;
sum1 = min(a, b);
sum2 = min(c, d);
if (sum1 + sum2 <= n) {
m = i;
p = sum1;
q = sum2 + (n - (sum1 + sum2));
}
}
if (m == 0)
cout << "-1" << endl;
else
cout << m << " " << p << " " << q << endl;
}
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
Guy-Manuel and Thomas have an array a of n integers [a_1, a_2, ..., a_n]. In one step they can add 1 to any element of the array. Formally, in one step they can choose any integer index i (1 β€ i β€ n) and do a_i := a_i + 1.
If either the sum or the product of all elements in the array is equal to zero, Guy-Manuel and Thomas do not mind to do this operation one more time.
What is the minimum number of steps they need to do to make both the sum and the product of all elements in the array different from zero? Formally, find the minimum number of steps to make a_1 + a_2 + ... + a_n β 0 and a_1 β
a_2 β
... β
a_n β 0.
Input
Each test contains multiple test cases.
The first line contains the number of test cases t (1 β€ t β€ 10^3). The description of the test cases follows.
The first line of each test case contains an integer n (1 β€ n β€ 100) β the size of the array.
The second line of each test case contains n integers a_1, a_2, ..., a_n (-100 β€ a_i β€ 100) β elements of the array .
Output
For each test case, output the minimum number of steps required to make both sum and product of all elements in the array different from zero.
Example
Input
4
3
2 -1 -1
4
-1 0 0 1
2
-1 2
3
0 -2 1
Output
1
2
0
2
Note
In the first test case, the sum is 0. If we add 1 to the first element, the array will be [3,-1,-1], the sum will be equal to 1 and the product will be equal to 3.
In the second test case, both product and sum are 0. If we add 1 to the second and the third element, the array will be [-1,1,1,1], the sum will be equal to 2 and the product will be equal to -1. It can be shown that fewer steps can't be enough.
In the third test case, both sum and product are non-zero, we don't need to do anything.
In the fourth test case, after adding 1 twice to the first element the array will be [2,-2,1], the sum will be 1 and the product will be -4.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int t;
int n;
int a[2000000];
int s = 0;
int tong = 0;
void solve() {
cin >> n;
s = 0;
tong = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] == 0) {
s++;
a[i]++;
}
tong += a[i];
}
if (tong == 0) {
s++;
}
cout << s << endl;
}
int main() {
cin >> t;
while (t--) {
solve();
}
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
Peterson loves to learn new languages, but his favorite hobby is making new ones. Language is a set of words, and word is a sequence of lowercase Latin letters.
Peterson makes new language every morning. It is difficult task to store the whole language, so Peterson have invented new data structure for storing his languages which is called broom. Broom is rooted tree with edges marked with letters. Initially broom is represented by the only vertex β the root of the broom. When Peterson wants to add new word to the language he stands at the root and processes the letters of new word one by one. Consider that Peterson stands at the vertex u. If there is an edge from u marked with current letter, Peterson goes through this edge. Otherwise Peterson adds new edge from u to the new vertex v, marks it with the current letter and goes through the new edge. Size of broom is the number of vertices in it.
In the evening after working day Peterson can't understand the language he made this morning. It is too difficult for bored Peterson and he tries to make it simpler. Simplification of the language is the process of erasing some letters from some words of this language. Formally, Peterson takes some positive integer p and erases p-th letter from all the words of this language having length at least p. Letters in words are indexed starting by 1. Peterson considers that simplification should change at least one word, i.e. there has to be at least one word of length at least p. Peterson tries to make his language as simple as possible, so he wants to choose p such that the size of the broom for his simplified language is as small as possible.
Peterson is pretty annoyed with this task so he asks you for help. Write a program to find the smallest possible size of the broom and integer p.
Input
The first line of input contains integer n (2 β€ n β€ 3Β·105) β the size of the broom.
Next n - 1 lines describe the broom: i-th of them contains integers ui, vi and letter xi β describing the edge from ui to vi marked with letter xi.
Vertices are numbered from 1 to n. All xi are lowercase latin letters. Vertex 1 is the root of the broom.
Edges describe correct broom which is made from Peterson's language.
Output
The first line of output should contain the minimum possible size of the broom after its simplification. The second line of output should contain integer p to choose. If there are several suitable p values, print the smallest one.
Examples
Input
5
1 2 c
2 3 a
3 4 t
2 5 t
Output
3
2
Input
16
1 2 o
2 3 f
1 4 p
4 5 i
5 6 e
6 7 c
7 8 e
4 9 r
9 10 e
10 11 t
11 12 t
12 13 y
10 14 f
14 15 i
15 16 x
Output
12
2
Note
<image>
Broom from the second sample test can be built using language "piece", "of", "pie", "pretty", "prefix". Its simplification with p = 2 obtains the language of words "pece", "o", "pe", "petty", "pefix". This language gives us the broom with minimum possible size.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int son[600105][26], depth = 0, total, fi[600105], num[26], ans[600105], tot;
int newnode(int x) {
++tot;
for (int i = 0; i <= 25; i++) son[tot][i] = son[x][i];
return tot;
}
void merge(int &x, int y, int dep) {
if (!x || !y) {
x += y;
return;
}
ans[dep]++;
x = newnode(x);
for (int i = 0; i <= 25; i++) merge(son[x][i], son[y][i], dep);
}
void dfs(int x, int y) {
depth = max(depth, y);
ans[y - 1]++;
for (int i = 0; i <= 25; i++) {
int now = 0;
for (int j = 0; j <= 25; j++)
if (son[son[x][j]][i]) merge(now, son[son[x][j]][i], y);
}
for (int i = 0; i <= 25; i++)
if (son[x][i]) dfs(son[x][i], y + 1);
}
int main() {
int n;
scanf("%d", &n);
tot = n;
for (int i = 1; i <= n - 1; i++) {
int j, k;
char ch;
scanf("%d %d %c", &j, &k, &ch);
son[j][ch - 'a'] = k;
}
dfs(1, 1);
int sum = 0, sum1 = 0;
for (int i = 1; i <= depth; i++)
if (sum < ans[i]) sum = ans[i], sum1 = i;
printf("%d\n%d\n", n - sum, sum1);
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
Tom is interested in power consumption of his favourite laptop. His laptop has three modes. In normal mode laptop consumes P1 watt per minute. T1 minutes after Tom moved the mouse or touched the keyboard for the last time, a screensaver starts and power consumption changes to P2 watt per minute. Finally, after T2 minutes from the start of the screensaver, laptop switches to the "sleep" mode and consumes P3 watt per minute. If Tom moves the mouse or touches the keyboard when the laptop is in the second or in the third mode, it switches to the first (normal) mode. Tom's work with the laptop can be divided into n time periods [l1, r1], [l2, r2], ..., [ln, rn]. During each interval Tom continuously moves the mouse and presses buttons on the keyboard. Between the periods Tom stays away from the laptop. Find out the total amount of power consumed by the laptop during the period [l1, rn].
Input
The first line contains 6 integer numbers n, P1, P2, P3, T1, T2 (1 β€ n β€ 100, 0 β€ P1, P2, P3 β€ 100, 1 β€ T1, T2 β€ 60). The following n lines contain description of Tom's work. Each i-th of these lines contains two space-separated integers li and ri (0 β€ li < ri β€ 1440, ri < li + 1 for i < n), which stand for the start and the end of the i-th period of work.
Output
Output the answer to the problem.
Examples
Input
1 3 2 1 5 10
0 10
Output
30
Input
2 8 4 2 5 10
20 30
50 100
Output
570
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, P1, P2, P3, T1, T2;
cin >> n >> P1 >> P2 >> P3 >> T1 >> T2;
int a, b, c, d1, r = 0;
for (int i = 0; i < n; i++) {
cin >> a >> b;
if (i) {
int d = a - d1;
if (d > 0) {
r = r + min(d, T1) * P1;
d = d - T1;
}
if (d > 0) {
r = r + min(d, T2) * P2;
d = d - T2;
}
if (d > 0) r = r + d * P3;
}
r = r + (b - a) * P1;
c = a;
d1 = b;
}
cout << r;
return 0;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
You are given a simple weighted connected undirected graph, consisting of n vertices and m edges.
A path in the graph of length k is a sequence of k+1 vertices v_1, v_2, ..., v_{k+1} such that for each i (1 β€ i β€ k) the edge (v_i, v_{i+1}) is present in the graph. A path from some vertex v also has vertex v_1=v. Note that edges and vertices are allowed to be included in the path multiple times.
The weight of the path is the total weight of edges in it.
For each i from 1 to q consider a path from vertex 1 of length i of the maximum weight. What is the sum of weights of these q paths?
Answer can be quite large, so print it modulo 10^9+7.
Input
The first line contains a three integers n, m, q (2 β€ n β€ 2000; n - 1 β€ m β€ 2000; m β€ q β€ 10^9) β the number of vertices in the graph, the number of edges in the graph and the number of lengths that should be included in the answer.
Each of the next m lines contains a description of an edge: three integers v, u, w (1 β€ v, u β€ n; 1 β€ w β€ 10^6) β two vertices v and u are connected by an undirected edge with weight w. The graph contains no loops and no multiple edges. It is guaranteed that the given edges form a connected graph.
Output
Print a single integer β the sum of the weights of the paths from vertex 1 of maximum weights of lengths 1, 2, ..., q modulo 10^9+7.
Examples
Input
7 8 25
1 2 1
2 3 10
3 4 2
1 5 2
5 6 7
6 4 15
5 3 1
1 7 3
Output
4361
Input
2 1 5
1 2 4
Output
60
Input
15 15 23
13 10 12
11 14 12
2 15 5
4 10 8
10 2 4
10 7 5
3 10 1
5 6 11
1 13 8
9 15 4
4 2 9
11 15 1
11 12 14
10 8 12
3 6 11
Output
3250
Input
5 10 10000000
2 4 798
1 5 824
5 2 558
4 1 288
3 4 1890
3 1 134
2 3 1485
4 5 284
3 5 1025
1 2 649
Output
768500592
Note
Here is the graph for the first example:
<image>
Some maximum weight paths are:
* length 1: edges (1, 7) β weight 3;
* length 2: edges (1, 2), (2, 3) β weight 1+10=11;
* length 3: edges (1, 5), (5, 6), (6, 4) β weight 2+7+15=24;
* length 4: edges (1, 5), (5, 6), (6, 4), (6, 4) β weight 2+7+15+15=39;
* ...
So the answer is the sum of 25 terms: 3+11+24+39+...
In the second example the maximum weight paths have weights 4, 8, 12, 16 and 20.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long inter(pair<long long, long long> l1, pair<long long, long long> l2) {
return (l2.second - l1.second) / (l1.first - l2.first);
}
const long long MOD = 1e9 + 7;
inline void add(long long &a, long long b) { a = (a + b) % MOD; }
inline long long sum(long long a, long long b) { return (a + b) % MOD; }
long long mult(long long a, long long b) {
a %= MOD;
b %= MOD;
return (a * 1ll * b) % MOD;
}
long long b_pow(long long a, long long b) {
if (!b) {
return 1;
}
if (b & 1) {
return mult(b_pow(a, b - 1), a);
}
return b_pow(mult(a, a), b >> 1);
}
const long long N = 2010;
long long dp[N][N];
vector<pair<long long, long long>> g[N];
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, m, q;
cin >> n >> m >> q;
long long mx = 0;
for (long long i = 1; i <= m; i++) {
long long u, v, c;
cin >> u >> v >> c;
mx = max(mx, c);
g[u].push_back({v, c});
g[v].push_back({u, c});
}
for (long long i = 0; i <= n; i++) {
for (long long j = 0; j <= n; j++) {
dp[i][j] = -1e18;
}
}
dp[0][1] = 0;
for (long long i = 0; i + 1 < n; i++) {
for (long long v = 1; v <= n; v++) {
for (auto u : g[v]) {
dp[i + 1][u.first] = max(dp[i + 1][u.first], dp[i][v] + u.second);
}
}
}
long long ans = 0;
for (long long i = 1; i <= n - 1; i++) {
long long mx = 0;
for (long long v = 1; v <= n; v++) {
mx = max(mx, dp[i][v]);
}
add(ans, mx);
}
vector<pair<long long, long long>> lines;
map<long long, long long> best;
for (long long v = 1; v <= n; v++) {
long long k = 0;
for (auto u : g[v]) {
k = max(k, u.second);
}
best[k] = max(best[k], dp[n - 1][v]);
}
for (auto it : best) {
lines.push_back({it.first, it.second});
}
sort((lines).begin(), (lines).end());
vector<long long> to((long long)(lines).size());
for (long long i = 0; i < (long long)(lines).size(); i++) {
to[i] = q;
for (long long j = i + 1; j < (long long)(lines).size(); j++) {
long long x = inter(lines[i], lines[j]);
while (lines[j].first * (x - 1) + lines[j].second >=
lines[i].first * (x - 1) + lines[i].second) {
x--;
}
while (lines[j].first * x + lines[j].second <
lines[i].first * x + lines[i].second) {
x++;
}
x--;
to[i] = min(to[i], n - 1 + x);
}
}
long long cur = n;
long long inv2 = b_pow(2, MOD - 2);
for (long long i = 0; i < (long long)(lines).size(); i++) {
if (to[i] < cur) {
continue;
}
long long a0 = lines[i].first * (cur - (n - 1)) + lines[i].second,
an = lines[i].first * (to[i] - (n - 1)) + lines[i].second;
long long vl = mult(inv2, sum(a0, an));
add(ans, mult(vl, to[i] - cur + 1));
cur = to[i] + 1;
}
cout << ans << '\n';
}
``` |
### Prompt
Create a solution in cpp for the following problem:
One day Natalia was walking in the woods when she met a little mushroom gnome. The gnome told her the following story:
Everybody knows that the mushroom gnomes' power lies in the magic mushrooms that grow in the native woods of the gnomes. There are n trees and m magic mushrooms in the woods: the i-th tree grows at a point on a straight line with coordinates ai and has the height of hi, the j-th mushroom grows at the point with coordinates bj and has magical powers zj.
But one day wild mushroommunchers, the sworn enemies of mushroom gnomes unleashed a terrible storm on their home forest. As a result, some of the trees began to fall and crush the magic mushrooms. The supreme oracle of mushroom gnomes calculated in advance the probability for each tree that it will fall to the left, to the right or will stand on. If the tree with the coordinate x and height h falls to the left, then all the mushrooms that belong to the right-open interval [x - h, x), are destroyed. If a tree falls to the right, then the mushrooms that belong to the left-open interval (x, x + h] are destroyed. Only those mushrooms that are not hit by a single tree survive.
Knowing that all the trees fall independently of each other (i.e., all the events are mutually independent, and besides, the trees do not interfere with other trees falling in an arbitrary direction), the supreme oracle was also able to quickly calculate what would be the expectation of the total power of the mushrooms which survived after the storm. His calculations ultimately saved the mushroom gnomes from imminent death.
Natalia, as a good Olympiad programmer, got interested in this story, and she decided to come up with a way to quickly calculate the expectation of the sum of the surviving mushrooms' power.
Input
The first line contains two integers n and m (1 β€ n β€ 105, 1 β€ m β€ 104) β the number of trees and mushrooms, respectively.
Each of the next n lines contain four integers β ai, hi, li, ri (|ai| β€ 109, 1 β€ hi β€ 109, 0 β€ li, ri, li + ri β€ 100) which represent the coordinate of the i-th tree, its height, the percentage of the probabilities that the tree falls to the left and to the right, respectively (the remaining percentage is the probability that the tree will stand on).
Each of next m lines contain two integers bj, zj (|bj| β€ 109, 1 β€ zj β€ 103) which represent the coordinate and the magical power of the j-th mushroom, respectively.
An arbitrary number of trees and mushrooms can grow in one point.
Output
Print a real number β the expectation of the total magical power of the surviving mushrooms. The result is accepted with relative or absolute accuracy 10 - 4.
Examples
Input
1 1
2 2 50 50
1 1
Output
0.5000000000
Input
2 1
2 2 50 50
4 2 50 50
3 1
Output
0.2500000000
Note
It is believed that the mushroom with the coordinate x belongs to the right-open interval [l, r) if and only if l β€ x < r. Similarly, the mushroom with the coordinate x belongs to the left-open interval (l, r] if and only if l < x β€ r.
In the first test the mushroom survives with the probability of 50%, depending on where the single tree falls.
In the second test the mushroom survives only if neither of the two trees falls on it. It occurs with the probability of 50% Γ 50% = 25%.
Pretest β12 is the large test with 105 trees and one mushroom.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> x(n, 0), h(n, 0), l(n, 0), r(n, 0);
for (int i = 0; i < n; ++i) cin >> x[i] >> h[i] >> l[i] >> r[i];
vector<int> xM(m, 0), v(m, 0);
vector<pair<int, int>> all;
for (int i = 0; i < m; ++i) {
cin >> xM[i] >> v[i];
all.push_back(make_pair(xM[i], v[i]));
}
sort(all.begin(), all.end());
vector<double> sum(m + 5, 0);
auto cmp = [](pair<int, int> A, pair<int, int> B) {
if (A.first == B.first) return A.second < B.second;
return A.first < B.first;
};
for (int i = 0; i < n; ++i) {
auto startRight =
upper_bound(all.begin(), all.end(), make_pair(x[i], 1e9), cmp) -
all.begin();
auto endRight =
upper_bound(all.begin(), all.end(), make_pair(x[i] + h[i], 1e9), cmp) -
all.begin();
endRight--;
double rightProb = 0;
if (r[i] != 100)
rightProb = log((100 - r[i]) / 100.0);
else
rightProb = -1e9;
sum[startRight] += rightProb;
sum[endRight + 1] -= rightProb;
auto startLeft =
lower_bound(all.begin(), all.end(), make_pair(x[i] - h[i], -1e9), cmp) -
all.begin();
auto endLeft =
lower_bound(all.begin(), all.end(), make_pair(x[i] - 1, 1e9), cmp) -
all.begin();
double leftProb = 0;
if (l[i] != 100)
leftProb = log((100 - l[i]) / 100.0);
else
leftProb = -1e9;
endLeft--;
if (startLeft > endLeft) continue;
sum[startLeft] += leftProb;
sum[endLeft + 1] -= leftProb;
}
double now = 0, ans = 0;
for (int i = 0; i < m; ++i) {
now += sum[i];
ans += exp(now) * all[i].second;
}
cout.precision(15);
cout << ans << "\n";
}
``` |
### Prompt
Generate a cpp solution to the following problem:
You will be given a string S of length 3 representing the weather forecast for three days in the past.
The i-th character (1 \leq i \leq 3) of S represents the forecast for the i-th day. `S`, `C`, and `R` stand for sunny, cloudy, and rainy, respectively.
You will also be given a string T of length 3 representing the actual weather on those three days.
The i-th character (1 \leq i \leq 3) of S represents the actual weather on the i-th day. `S`, `C`, and `R` stand for sunny, cloudy, and rainy, respectively.
Print the number of days for which the forecast was correct.
Constraints
* S and T are strings of length 3 each.
* S and T consist of `S`, `C`, and `R`.
Input
Input is given from Standard Input in the following format:
S
T
Output
Print the number of days for which the forecast was correct.
Examples
Input
CSS
CSR
Output
2
Input
SSR
SSR
Output
3
Input
RRR
SSS
Output
0
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main()
{
string a,b;
int i,j,s=0;
cin>>a>>b;
for(i=0; i<3; i++){
if(a[i]==b[i]) s++;
}
cout<<s;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
Almost Identical Programs
The programming contest named Concours de Programmation Comtemporaine Interuniversitaire (CPCI) has a judging system similar to that of ICPC; contestants have to submit correct outputs for two different inputs to be accepted as a correct solution. Each of the submissions should include the program that generated the output. A pair of submissions is judged to be a correct solution when, in addition to the correctness of the outputs, they include an identical program.
Many contestants, however, do not stop including a different version of their programs in their second submissions, after modifying a single string literal in their programs representing the input file name, attempting to process different input. The organizers of CPCI are exploring the possibility of showing a special error message for such close submissions, indicating contestants what's wrong with such submissions. Your task is to detect such close submissions.
Input
The input consists of at most 100 datasets, each in the following format.
s1
s2
Each of s1 and s2 is a string written in a line, with the length between 1 and 200, inclusive. They are the first and the second submitted programs respectively. A program consists of lowercase letters (`a`, `b`, ..., `z`), uppercase letters (`A`, `B`, ..., `Z`), digits (`0`, `1`, ..., `9`), double quotes (`"`), and semicolons (`;`). When double quotes occur in a program, there are always even number of them.
The end of the input is indicated by a line containing one '`.`' (period).
Output
For each dataset, print the judge result in a line.
If the given two programs are identical, print `IDENTICAL`. If two programs differ with only one corresponding string literal, print `CLOSE`. Otherwise, print `DIFFERENT`. A string literal is a possibly empty sequence of characters between an odd-numbered occurrence of a double quote and the next occurrence of a double quote.
Sample Input
print"hello";print123
print"hello";print123
read"B1input";solve;output;
read"B2";solve;output;
read"C1";solve;output"C1ans";
read"C2";solve;output"C2ans";
""""""""
"""42"""""
slow"program"
fast"code"
"super"fast"program"
"super"faster"program"
X""
X
I"S""CREAM"
I"CE""CREAM"
11"22"11
1"33"111
.
Output for the Sample Input
IDENTICAL
CLOSE
DIFFERENT
CLOSE
DIFFERENT
DIFFERENT
DIFFERENT
CLOSE
DIFFERENT
Example
Input
print"hello";print123
print"hello";print123
read"B1input";solve;output;
read"B2";solve;output;
read"C1";solve;output"C1ans";
read"C2";solve;output"C2ans";
""""""""
"""42"""""
slow"program"
fast"code"
"super"fast"program"
"super"faster"program"
X""
X
I"S""CREAM"
I"CE""CREAM"
11"22"11
1"33"111
.
Output
IDENTICAL
CLOSE
DIFFERENT
CLOSE
DIFFERENT
DIFFERENT
DIFFERENT
CLOSE
DIFFERENT
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
bool is_identical(string s1, string s2)
{
return s1 == s2;
}
string s1, s2;
int main()
{
while (true)
{
int cnt = 0;
cin >> s1;
if (s1[0] == '.')
break;
cin >> s2;
int end1=0,end2 = 0;
int start = 0;
bool iden = false, close = false, diff = false;
if (s1 == s2)
iden = true;
bool d = false;
for (int i = 0; i < s1.size(); i++)
{
if (s1[i] == '"' && s2[i] == '"'){cnt = 1;d = !d;start = i;}
else if (s1[i] != s2[i])
{
if (!d){diff = true;break;}
else {if(cnt == 1) {close = true;break;}}
}
}
if(close == true){
for(int i = start+1;i<max(s1.size(),s2.size());i++){
if(end1!=0 && end2!=0) break;
if(s1[i]=='"' && end1 == 0) end1 = i;
if(s2[i]=='"' && end2 == 0) end2 = i;
}
}
s1 = s1.substr(end1+1);
s2 = s2.substr(end2+1);
if(s1==s2) iden =true;
else diff = true;
if(iden && !close) cout << "IDENTICAL" << endl;
else if(iden && close) cout << "CLOSE" << endl;
else cout << "DIFFERENT" << endl;
}
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
Dr. Bruce Banner hates his enemies (like others don't). As we all know, he can barely talk when he turns into the incredible Hulk. That's why he asked you to help him to express his feelings.
Hulk likes the Inception so much, and like that his feelings are complicated. They have n layers. The first layer is hate, second one is love, third one is hate and so on...
For example if n = 1, then his feeling is "I hate it" or if n = 2 it's "I hate that I love it", and if n = 3 it's "I hate that I love that I hate it" and so on.
Please help Dr. Banner.
Input
The only line of the input contains a single integer n (1 β€ n β€ 100) β the number of layers of love and hate.
Output
Print Dr.Banner's feeling in one line.
Examples
Input
1
Output
I hate it
Input
2
Output
I hate that I love it
Input
3
Output
I hate that I love that I hate it
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cout << "I ";
if (i % 2 != 0) {
cout << "hate ";
} else {
cout << "love ";
}
if (i != n) {
cout << "that ";
}
}
cout << "it";
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
You are given an integer N. Find the number of the positive divisors of N!, modulo 10^9+7.
Constraints
* 1β€Nβ€10^3
Input
The input is given from Standard Input in the following format:
N
Output
Print the number of the positive divisors of N!, modulo 10^9+7.
Examples
Input
3
Output
4
Input
6
Output
30
Input
1000
Output
972926972
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int A[1010] = {};
long long int B[1010] = {};
for(int i = 1; i <= N; i++) {
A[i] = i;
B[i] = 1;
}
for (int j = 2; j <= N; j++) {
for (int i = 1; i <= N; i++) {
while(A[i] % j == 0){
B[j] ++;
A[i] /= j;
}
}
}
long long int ans = 1;
long long int P = 1e9 + 7;
for(int i = 1; i <= N; i++) {
ans = (ans * B[i]) % P;
}
cout << ans << endl;
}
``` |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.